InspectorProtocolObjects.h source code [webkit/WebKitBuild/Debug/JavaScriptCore.framework/Versions/A/PrivateHeaders/InspectorProtocolObjects.h]

1	/*
2	* Copyright (C) 2013 Google Inc. All rights reserved.
3	* Copyright (C) 2013-2016 Apple Inc. All rights reserved.
4	* Copyright (C) 2014 University of Washington. All rights reserved.
5	*
6	* Redistribution and use in source and binary forms, with or without
7	* modification, are permitted provided that the following conditions
8	* are met:
9	* 1. Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.
11	* 2. Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.
14	*
15	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
16	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
17	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
19	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
20	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
21	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
22	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
23	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
24	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
25	* THE POSSIBILITY OF SUCH DAMAGE.
26	*/
27
28	// DO NOT EDIT THIS FILE. It is automatically generated from CombinedDomains.json by the script: Source/JavaScriptCore/inspector/scripts/generate-inspector-protocol-bindings.py
29
30	#pragma once
31
32	#include "InspectorProtocolTypes.h"
33	#include <wtf/JSONValues.h>
34	#include <wtf/text/WTFString.h>
35
36	namespace Inspector {
37
38
39
40	namespace Protocol {
41
42	// Versions.
43	namespace Audit {
44	static constexpr unsigned VERSION = `3`;
45	} // Audit
46
47	namespace Recording {
48	static constexpr unsigned VERSION = `1`;
49	} // Recording
50	// End of versions.
51
52
53	// Forward declarations.
54	namespace Animation {
55	class Animation;
56	class Effect;
57	class Keyframe;
58	class TrackingUpdate;
59	enum class AnimationState;
60	enum class PlaybackDirection;
61	enum class FillMode;
62	} // Animation
63
64	namespace ApplicationCache {
65	class ApplicationCacheResource;
66	class ApplicationCache;
67	class FrameWithManifest;
68	} // ApplicationCache
69
70	namespace Browser {
71	class Extension;
72	} // Browser
73
74	#if defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE
75	namespace CPUProfiler {
76	class ThreadInfo;
77	class Event;
78	} // CPUProfiler
79	#endif // defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE
80
81	namespace CSS {
82	class CSSStyleId;
83	class CSSRuleId;
84	class PseudoIdMatches;
85	class InheritedStyleEntry;
86	class RuleMatch;
87	class CSSSelector;
88	class SelectorList;
89	class CSSStyleAttribute;
90	class CSSStyleSheetHeader;
91	class CSSStyleSheetBody;
92	class CSSRule;
93	class SourceRange;
94	class ShorthandEntry;
95	class CSSPropertyInfo;
96	class CSSComputedStyleProperty;
97	class CSSStyle;
98	class CSSProperty;
99	class Grouping;
100	class Font;
101	class FontVariationAxis;
102	enum class StyleSheetOrigin;
103	enum class PseudoId;
104	enum class CSSPropertyStatus;
105	enum class LayoutContextType;
106	enum class LayoutContextTypeChangedMode;
107	} // CSS
108
109	namespace Canvas {
110	class ContextAttributes;
111	class Canvas;
112	#if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) \|\| (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
113	class ShaderProgram;
114	#endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) \|\| (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
115	enum class ContextType;
116	#if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) \|\| (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
117	enum class ProgramType;
118	#endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) \|\| (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
119	#if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) \|\| (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
120	enum class ShaderType;
121	#endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) \|\| (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
122	} // Canvas
123
124	namespace Console {
125	class Channel;
126	class ConsoleMessage;
127	class CallFrame;
128	class StackTrace;
129	enum class ChannelSource;
130	enum class ChannelLevel;
131	} // Console
132
133	namespace DOM {
134	class Node;
135	class DataBinding;
136	class EventListener;
137	class AccessibilityProperties;
138	class RGBAColor;
139	class HighlightConfig;
140	enum class PseudoType;
141	enum class ShadowRootType;
142	enum class CustomElementState;
143	enum class LiveRegionRelevant;
144	} // DOM
145
146	namespace DOMDebugger {
147	enum class DOMBreakpointType;
148	enum class EventBreakpointType;
149	} // DOMDebugger
150
151	namespace DOMStorage {
152	class StorageId;
153	} // DOMStorage
154
155	namespace Database {
156	class Database;
157	class Error;
158	} // Database
159
160	namespace Debugger {
161	class Location;
162	class BreakpointAction;
163	class BreakpointOptions;
164	class FunctionDetails;
165	class CallFrame;
166	class Scope;
167	class ProbeSample;
168	class AssertPauseReason;
169	class BreakpointPauseReason;
170	class CSPViolationPauseReason;
171	} // Debugger
172
173	namespace GenericTypes {
174	class SearchMatch;
175	} // GenericTypes
176
177	namespace Heap {
178	class GarbageCollection;
179	} // Heap
180
181	namespace IndexedDB {
182	class DatabaseWithObjectStores;
183	class ObjectStore;
184	class ObjectStoreIndex;
185	class Key;
186	class KeyRange;
187	class DataEntry;
188	class KeyPath;
189	} // IndexedDB
190
191	namespace LayerTree {
192	class IntRect;
193	class Layer;
194	class CompositingReasons;
195	} // LayerTree
196
197	#if defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE
198	namespace Memory {
199	class Event;
200	class CategoryData;
201	} // Memory
202	#endif // defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE
203
204	namespace Network {
205	class Headers;
206	class ResourceTiming;
207	class Request;
208	class Response;
209	class Metrics;
210	class WebSocketRequest;
211	class WebSocketResponse;
212	class WebSocketFrame;
213	class CachedResource;
214	class Initiator;
215	enum class NetworkStage;
216	enum class ResourceErrorType;
217	} // Network
218
219	namespace Page {
220	class Frame;
221	class FrameResource;
222	class FrameResourceTree;
223	class SearchResult;
224	class Cookie;
225	enum class Setting;
226	enum class ResourceType;
227	enum class CoordinateSystem;
228	enum class CookieSameSitePolicy;
229	#if (defined(ENABLE_DARK_MODE_CSS) && ENABLE_DARK_MODE_CSS) \|\| (defined(HAVE_OS_DARK_MODE_SUPPORT) && HAVE_OS_DARK_MODE_SUPPORT)
230	enum class Appearance;
231	#endif // (defined(ENABLE_DARK_MODE_CSS) && ENABLE_DARK_MODE_CSS) \|\| (defined(HAVE_OS_DARK_MODE_SUPPORT) && HAVE_OS_DARK_MODE_SUPPORT)
232	} // Page
233
234	namespace Recording {
235	class InitialState;
236	class Frame;
237	class Recording;
238	enum class Type;
239	enum class Initiator;
240	} // Recording
241
242	namespace Runtime {
243	class RemoteObject;
244	class ObjectPreview;
245	class PropertyPreview;
246	class EntryPreview;
247	class CollectionEntry;
248	class PropertyDescriptor;
249	class InternalPropertyDescriptor;
250	class CallArgument;
251	class ExecutionContextDescription;
252	class ErrorRange;
253	class StructureDescription;
254	class TypeSet;
255	class TypeDescription;
256	class TypeLocation;
257	class BasicBlock;
258	enum class ExecutionContextType;
259	enum class SyntaxErrorType;
260	} // Runtime
261
262	namespace ScriptProfiler {
263	class Event;
264	class ExpressionLocation;
265	class StackFrame;
266	class StackTrace;
267	class Samples;
268	enum class EventType;
269	} // ScriptProfiler
270
271	namespace Security {
272	class Connection;
273	class Certificate;
274	class Security;
275	} // Security
276
277	#if defined(ENABLE_SERVICE_WORKER) && ENABLE_SERVICE_WORKER
278	namespace ServiceWorker {
279	class Configuration;
280	} // ServiceWorker
281	#endif // defined(ENABLE_SERVICE_WORKER) && ENABLE_SERVICE_WORKER
282
283	namespace Target {
284	class TargetInfo;
285	} // Target
286
287	namespace Timeline {
288	class TimelineEvent;
289	enum class EventType;
290	enum class Instrument;
291	} // Timeline
292	// End of forward declarations.
293
294
295	// Typedefs.
296	namespace Animation {
297	/ Unique Web Animation identifier. /
298	using AnimationId = String;
299	} // Animation
300
301	namespace Browser {
302	/ Unique extension identifier. /
303	using ExtensionId = String;
304	} // Browser
305
306	namespace CSS {
307	using StyleSheetId = String;
308	} // CSS
309
310	namespace Canvas {
311	/ Unique canvas identifier. /
312	using CanvasId = String;
313	#if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) \|\| (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
314	/ Unique shader program identifier. /
315	using ProgramId = String;
316	#endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) \|\| (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
317	} // Canvas
318
319	namespace DOM {
320	/ Unique DOM node identifier. /
321	using NodeId = int;
322	/ Unique event listener identifier. /
323	using EventListenerId = int;
324	/ An array of quad vertices, x immediately followed by y for each point, points clock-wise. /
325	using Quad = JSON::ArrayOf<double>;
326	} // DOM
327
328	namespace DOMStorage {
329	/ DOM Storage item. /
330	using Item = JSON::ArrayOf<String>;
331	} // DOMStorage
332
333	namespace Database {
334	/ Unique identifier of Database object. /
335	using DatabaseId = String;
336	} // Database
337
338	namespace Debugger {
339	/ Breakpoint identifier. /
340	using BreakpointId = String;
341	/ Breakpoint action identifier. /
342	using BreakpointActionIdentifier = int;
343	/ Unique script identifier. /
344	using ScriptId = String;
345	/ Call frame identifier. /
346	using CallFrameId = String;
347	} // Debugger
348
349	namespace Heap {
350	/ JavaScriptCore HeapSnapshot JSON data. /
351	using HeapSnapshotData = String;
352	} // Heap
353
354	namespace LayerTree {
355	/ Unique RenderLayer identifier. /
356	using LayerId = String;
357	/ Unique PseudoElement identifier. /
358	using PseudoElementId = String;
359	} // LayerTree
360
361	namespace Network {
362	/ Unique loader identifier. /
363	using LoaderId = String;
364	/ Unique frame identifier. /
365	using FrameId = String;
366	/ Unique request identifier. /
367	using RequestId = String;
368	/ Elapsed seconds since frontend connected. /
369	using Timestamp = double;
370	/ Number of seconds since epoch. /
371	using Walltime = double;
372	} // Network
373
374	namespace Runtime {
375	/ Unique object identifier. /
376	using RemoteObjectId = String;
377	/ Id of an execution context. /
378	using ExecutionContextId = int;
379	} // Runtime
380	// End of typedefs.
381
382	namespace Helpers {
383
384	JS_EXPORT_PRIVATE String getEnumConstantValue(int code);
385
386	template<typename T> String getEnumConstantValue(T enumValue)
387	{
388	return getEnumConstantValue(static_cast<int>(enumValue));
389	}
390
391	} // namespace Helpers
392
393	namespace Animation {
394
395	enum class AnimationState {
396	Ready = `0`,
397	Delayed = `1`,
398	Active = `2`,
399	Canceled = `3`,
400	Done = `4`,
401	}; // enum class AnimationState
402
403	enum class PlaybackDirection {
404	Normal = `5`,
405	Reverse = `6`,
406	Alternate = `7`,
407	AlternateReverse = `8`,
408	}; // enum class PlaybackDirection
409
410	enum class FillMode {
411	None = `9`,
412	Forwards = `10`,
413	Backwards = `11`,
414	Both = `12`,
415	Auto = `13`,
416	}; // enum class FillMode
417
418	class Animation final : public JSON::ObjectBase {
419	public:
420	enum {
421	NoFieldsSet = `0`,
422	AnimationIdSet = `1` << `0`,
423	AllFieldsSet = (AnimationIdSet)
424	};
425
426	template<int STATE>
427	class Builder {
428	private:
429	RefPtr<JSON::Object> m_result;
430
431	template<int STEP> Builder<STATE \| STEP>& castState()
432	{
433	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
434	}
435
436	Builder(Ref</Animation/JSON::Object>&& object)
437	: m_result (WTFMove(object))
438	{
439	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
440	}
441	friend class Animation;
442	public:
443
444	Builder<STATE \| AnimationIdSet>& setAnimationId(const String& in_animationId)
445	{
446	COMPILE_ASSERT(!(STATE & AnimationIdSet), property_animationId_already_set);
447	m_result ->setString("animationId"_s, in_animationId);
448	return castState<AnimationIdSet>();
449	}
450
451	Ref<Animation> release()
452	{
453	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
454	COMPILE_ASSERT(sizeof(Animation) == sizeof(JSON::Object), cannot_cast);
455
456	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
457	auto result = WTFMove(*reinterpret_cast<Ref<Animation>*>(&jsonResult));
458	return result;
459	}
460	};
461
462	/*
463	* Synthetic constructor:
464	* Ref<Animation> result = Animation::create()
465	* .setAnimationId(...)
466	* .release();
467	*/
468	static Builder<NoFieldsSet> create()
469	{
470	return Builder<NoFieldsSet>(JSON::Object::create());
471	}
472
473	void setName(const String& in_opt_name)
474	{
475	JSON::ObjectBase::setString("name"_s, in_opt_name);
476	}
477
478	void setCssAnimationName(const String& in_opt_cssAnimationName)
479	{
480	JSON::ObjectBase::setString("cssAnimationName"_s, in_opt_cssAnimationName);
481	}
482
483	void setCssTransitionProperty(const String& in_opt_cssTransitionProperty)
484	{
485	JSON::ObjectBase::setString("cssTransitionProperty"_s, in_opt_cssTransitionProperty);
486	}
487
488	void setEffect(Ref<Protocol::Animation::Effect>&& in_opt_effect)
489	{
490	JSON::ObjectBase::setObject("effect"_s, WTFMove(in_opt_effect));
491	}
492
493	void setBacktrace(Ref<JSON::ArrayOf<Protocol::Console::CallFrame>>&& in_opt_backtrace)
494	{
495	JSON::ObjectBase::setArray("backtrace"_s, WTFMove(in_opt_backtrace));
496	}
497	};
498
499	class Effect final : public JSON::ObjectBase {
500	public:
501	enum {
502	NoFieldsSet = `0`,
503	AllFieldsSet = `0`
504	};
505
506	template<int STATE>
507	class Builder {
508	private:
509	RefPtr<JSON::Object> m_result;
510
511	template<int STEP> Builder<STATE \| STEP>& castState()
512	{
513	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
514	}
515
516	Builder(Ref</Effect/JSON::Object>&& object)
517	: m_result (WTFMove(object))
518	{
519	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
520	}
521	friend class Effect;
522	public:
523
524	Ref<Effect> release()
525	{
526	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
527	COMPILE_ASSERT(sizeof(Effect) == sizeof(JSON::Object), cannot_cast);
528
529	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
530	auto result = WTFMove(*reinterpret_cast<Ref<Effect>*>(&jsonResult));
531	return result;
532	}
533	};
534
535	/*
536	* Synthetic constructor:
537	* Ref<Effect> result = Effect::create()
538	* .release();
539	*/
540	static Builder<NoFieldsSet> create()
541	{
542	return Builder<NoFieldsSet>(JSON::Object::create());
543	}
544
545	void setStartDelay(double in_opt_startDelay)
546	{
547	JSON::ObjectBase::setDouble("startDelay"_s, in_opt_startDelay);
548	}
549
550	void setEndDelay(double in_opt_endDelay)
551	{
552	JSON::ObjectBase::setDouble("endDelay"_s, in_opt_endDelay);
553	}
554
555	void setIterationCount(double in_opt_iterationCount)
556	{
557	JSON::ObjectBase::setDouble("iterationCount"_s, in_opt_iterationCount);
558	}
559
560	void setIterationStart(double in_opt_iterationStart)
561	{
562	JSON::ObjectBase::setDouble("iterationStart"_s, in_opt_iterationStart);
563	}
564
565	void setIterationDuration(double in_opt_iterationDuration)
566	{
567	JSON::ObjectBase::setDouble("iterationDuration"_s, in_opt_iterationDuration);
568	}
569
570	void setTimingFunction(const String& in_opt_timingFunction)
571	{
572	JSON::ObjectBase::setString("timingFunction"_s, in_opt_timingFunction);
573	}
574
575	void setPlaybackDirection(Protocol::Animation::PlaybackDirection in_opt_playbackDirection)
576	{
577	JSON::ObjectBase::setString("playbackDirection"_s, Protocol::Helpers::getEnumConstantValue(in_opt_playbackDirection));
578	}
579
580	void setFillMode(Protocol::Animation::FillMode in_opt_fillMode)
581	{
582	JSON::ObjectBase::setString("fillMode"_s, Protocol::Helpers::getEnumConstantValue(in_opt_fillMode));
583	}
584
585	void setKeyframes(Ref<JSON::ArrayOf<Protocol::Animation::Keyframe>>&& in_opt_keyframes)
586	{
587	JSON::ObjectBase::setArray("keyframes"_s, WTFMove(in_opt_keyframes));
588	}
589	};
590
591	class Keyframe final : public JSON::ObjectBase {
592	public:
593	enum {
594	NoFieldsSet = `0`,
595	OffsetSet = `1` << `0`,
596	AllFieldsSet = (OffsetSet)
597	};
598
599	template<int STATE>
600	class Builder {
601	private:
602	RefPtr<JSON::Object> m_result;
603
604	template<int STEP> Builder<STATE \| STEP>& castState()
605	{
606	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
607	}
608
609	Builder(Ref</Keyframe/JSON::Object>&& object)
610	: m_result (WTFMove(object))
611	{
612	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
613	}
614	friend class Keyframe;
615	public:
616
617	Builder<STATE \| OffsetSet>& setOffset(double in_offset)
618	{
619	COMPILE_ASSERT(!(STATE & OffsetSet), property_offset_already_set);
620	m_result ->setDouble("offset"_s, in_offset);
621	return castState<OffsetSet>();
622	}
623
624	Ref<Keyframe> release()
625	{
626	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
627	COMPILE_ASSERT(sizeof(Keyframe) == sizeof(JSON::Object), cannot_cast);
628
629	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
630	auto result = WTFMove(*reinterpret_cast<Ref<Keyframe>*>(&jsonResult));
631	return result;
632	}
633	};
634
635	/*
636	* Synthetic constructor:
637	* Ref<Keyframe> result = Keyframe::create()
638	* .setOffset(...)
639	* .release();
640	*/
641	static Builder<NoFieldsSet> create()
642	{
643	return Builder<NoFieldsSet>(JSON::Object::create());
644	}
645
646	void setEasing(const String& in_opt_easing)
647	{
648	JSON::ObjectBase::setString("easing"_s, in_opt_easing);
649	}
650
651	void setStyle(const String& in_opt_style)
652	{
653	JSON::ObjectBase::setString("style"_s, in_opt_style);
654	}
655	};
656
657	class TrackingUpdate final : public JSON::ObjectBase {
658	public:
659	enum {
660	NoFieldsSet = `0`,
661	TrackingAnimationIdSet = `1` << `0`,
662	AnimationStateSet = `1` << `1`,
663	AllFieldsSet = (TrackingAnimationIdSet \| AnimationStateSet)
664	};
665
666	template<int STATE>
667	class Builder {
668	private:
669	RefPtr<JSON::Object> m_result;
670
671	template<int STEP> Builder<STATE \| STEP>& castState()
672	{
673	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
674	}
675
676	Builder(Ref</TrackingUpdate/JSON::Object>&& object)
677	: m_result (WTFMove(object))
678	{
679	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
680	}
681	friend class TrackingUpdate;
682	public:
683
684	Builder<STATE \| TrackingAnimationIdSet>& setTrackingAnimationId(const String& in_trackingAnimationId)
685	{
686	COMPILE_ASSERT(!(STATE & TrackingAnimationIdSet), property_trackingAnimationId_already_set);
687	m_result ->setString("trackingAnimationId"_s, in_trackingAnimationId);
688	return castState<TrackingAnimationIdSet>();
689	}
690
691	Builder<STATE \| AnimationStateSet>& setAnimationState(Protocol::Animation::AnimationState in_animationState)
692	{
693	COMPILE_ASSERT(!(STATE & AnimationStateSet), property_animationState_already_set);
694	m_result ->setString("animationState"_s, Protocol::Helpers::getEnumConstantValue(in_animationState));
695	return castState<AnimationStateSet>();
696	}
697
698	Ref<TrackingUpdate> release()
699	{
700	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
701	COMPILE_ASSERT(sizeof(TrackingUpdate) == sizeof(JSON::Object), cannot_cast);
702
703	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
704	auto result = WTFMove(*reinterpret_cast<Ref<TrackingUpdate>*>(&jsonResult));
705	return result;
706	}
707	};
708
709	/*
710	* Synthetic constructor:
711	* Ref<TrackingUpdate> result = TrackingUpdate::create()
712	* .setTrackingAnimationId(...)
713	* .setAnimationState(...)
714	* .release();
715	*/
716	static Builder<NoFieldsSet> create()
717	{
718	return Builder<NoFieldsSet>(JSON::Object::create());
719	}
720
721	void setNodeId(int in_opt_nodeId)
722	{
723	JSON::ObjectBase::setInteger("nodeId"_s, in_opt_nodeId);
724	}
725
726	void setAnimationName(const String& in_opt_animationName)
727	{
728	JSON::ObjectBase::setString("animationName"_s, in_opt_animationName);
729	}
730
731	void setTransitionProperty(const String& in_opt_transitionProperty)
732	{
733	JSON::ObjectBase::setString("transitionProperty"_s, in_opt_transitionProperty);
734	}
735	};
736
737	} // Animation
738
739	namespace ApplicationCache {
740
741	/ Detailed application cache resource information. /
742	class ApplicationCacheResource final : public JSON::ObjectBase {
743	public:
744	enum {
745	NoFieldsSet = `0`,
746	UrlSet = `1` << `0`,
747	SizeSet = `1` << `1`,
748	TypeSet = `1` << `2`,
749	AllFieldsSet = (UrlSet \| SizeSet \| TypeSet)
750	};
751
752	template<int STATE>
753	class Builder {
754	private:
755	RefPtr<JSON::Object> m_result;
756
757	template<int STEP> Builder<STATE \| STEP>& castState()
758	{
759	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
760	}
761
762	Builder(Ref</ApplicationCacheResource/JSON::Object>&& object)
763	: m_result (WTFMove(object))
764	{
765	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
766	}
767	friend class ApplicationCacheResource;
768	public:
769
770	Builder<STATE \| UrlSet>& setUrl(const String& in_url)
771	{
772	COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
773	m_result ->setString("url"_s, in_url);
774	return castState<UrlSet>();
775	}
776
777	Builder<STATE \| SizeSet>& setSize(int in_size)
778	{
779	COMPILE_ASSERT(!(STATE & SizeSet), property_size_already_set);
780	m_result ->setInteger("size"_s, in_size);
781	return castState<SizeSet>();
782	}
783
784	Builder<STATE \| TypeSet>& setType(const String& in_type)
785	{
786	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
787	m_result ->setString("type"_s, in_type);
788	return castState<TypeSet>();
789	}
790
791	Ref<ApplicationCacheResource> release()
792	{
793	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
794	COMPILE_ASSERT(sizeof(ApplicationCacheResource) == sizeof(JSON::Object), cannot_cast);
795
796	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
797	auto result = WTFMove(*reinterpret_cast<Ref<ApplicationCacheResource>*>(&jsonResult));
798	return result;
799	}
800	};
801
802	/*
803	* Synthetic constructor:
804	* Ref<ApplicationCacheResource> result = ApplicationCacheResource::create()
805	* .setUrl(...)
806	* .setSize(...)
807	* .setType(...)
808	* .release();
809	*/
810	static Builder<NoFieldsSet> create()
811	{
812	return Builder<NoFieldsSet>(JSON::Object::create());
813	}
814	};
815
816	/ Detailed application cache information. /
817	class ApplicationCache final : public JSON::ObjectBase {
818	public:
819	enum {
820	NoFieldsSet = `0`,
821	ManifestURLSet = `1` << `0`,
822	SizeSet = `1` << `1`,
823	CreationTimeSet = `1` << `2`,
824	UpdateTimeSet = `1` << `3`,
825	ResourcesSet = `1` << `4`,
826	AllFieldsSet = (ManifestURLSet \| SizeSet \| CreationTimeSet \| UpdateTimeSet \| ResourcesSet)
827	};
828
829	template<int STATE>
830	class Builder {
831	private:
832	RefPtr<JSON::Object> m_result;
833
834	template<int STEP> Builder<STATE \| STEP>& castState()
835	{
836	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
837	}
838
839	Builder(Ref</ApplicationCache/JSON::Object>&& object)
840	: m_result (WTFMove(object))
841	{
842	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
843	}
844	friend class ApplicationCache;
845	public:
846
847	Builder<STATE \| ManifestURLSet>& setManifestURL(const String& in_manifestURL)
848	{
849	COMPILE_ASSERT(!(STATE & ManifestURLSet), property_manifestURL_already_set);
850	m_result ->setString("manifestURL"_s, in_manifestURL);
851	return castState<ManifestURLSet>();
852	}
853
854	Builder<STATE \| SizeSet>& setSize(double in_size)
855	{
856	COMPILE_ASSERT(!(STATE & SizeSet), property_size_already_set);
857	m_result ->setDouble("size"_s, in_size);
858	return castState<SizeSet>();
859	}
860
861	Builder<STATE \| CreationTimeSet>& setCreationTime(double in_creationTime)
862	{
863	COMPILE_ASSERT(!(STATE & CreationTimeSet), property_creationTime_already_set);
864	m_result ->setDouble("creationTime"_s, in_creationTime);
865	return castState<CreationTimeSet>();
866	}
867
868	Builder<STATE \| UpdateTimeSet>& setUpdateTime(double in_updateTime)
869	{
870	COMPILE_ASSERT(!(STATE & UpdateTimeSet), property_updateTime_already_set);
871	m_result ->setDouble("updateTime"_s, in_updateTime);
872	return castState<UpdateTimeSet>();
873	}
874
875	Builder<STATE \| ResourcesSet>& setResources(Ref<JSON::ArrayOf<Protocol::ApplicationCache::ApplicationCacheResource>>&& in_resources)
876	{
877	COMPILE_ASSERT(!(STATE & ResourcesSet), property_resources_already_set);
878	m_result ->setArray("resources"_s, WTFMove(in_resources));
879	return castState<ResourcesSet>();
880	}
881
882	Ref<ApplicationCache> release()
883	{
884	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
885	COMPILE_ASSERT(sizeof(ApplicationCache) == sizeof(JSON::Object), cannot_cast);
886
887	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
888	auto result = WTFMove(*reinterpret_cast<Ref<ApplicationCache>*>(&jsonResult));
889	return result;
890	}
891	};
892
893	/*
894	* Synthetic constructor:
895	* Ref<ApplicationCache> result = ApplicationCache::create()
896	* .setManifestURL(...)
897	* .setSize(...)
898	* .setCreationTime(...)
899	* .setUpdateTime(...)
900	* .setResources(...)
901	* .release();
902	*/
903	static Builder<NoFieldsSet> create()
904	{
905	return Builder<NoFieldsSet>(JSON::Object::create());
906	}
907	};
908
909	/ Frame identifier - manifest URL pair. /
910	class FrameWithManifest final : public JSON::ObjectBase {
911	public:
912	enum {
913	NoFieldsSet = `0`,
914	FrameIdSet = `1` << `0`,
915	ManifestURLSet = `1` << `1`,
916	StatusSet = `1` << `2`,
917	AllFieldsSet = (FrameIdSet \| ManifestURLSet \| StatusSet)
918	};
919
920	template<int STATE>
921	class Builder {
922	private:
923	RefPtr<JSON::Object> m_result;
924
925	template<int STEP> Builder<STATE \| STEP>& castState()
926	{
927	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
928	}
929
930	Builder(Ref</FrameWithManifest/JSON::Object>&& object)
931	: m_result (WTFMove(object))
932	{
933	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
934	}
935	friend class FrameWithManifest;
936	public:
937
938	Builder<STATE \| FrameIdSet>& setFrameId(const String& in_frameId)
939	{
940	COMPILE_ASSERT(!(STATE & FrameIdSet), property_frameId_already_set);
941	m_result ->setString("frameId"_s, in_frameId);
942	return castState<FrameIdSet>();
943	}
944
945	Builder<STATE \| ManifestURLSet>& setManifestURL(const String& in_manifestURL)
946	{
947	COMPILE_ASSERT(!(STATE & ManifestURLSet), property_manifestURL_already_set);
948	m_result ->setString("manifestURL"_s, in_manifestURL);
949	return castState<ManifestURLSet>();
950	}
951
952	Builder<STATE \| StatusSet>& setStatus(int in_status)
953	{
954	COMPILE_ASSERT(!(STATE & StatusSet), property_status_already_set);
955	m_result ->setInteger("status"_s, in_status);
956	return castState<StatusSet>();
957	}
958
959	Ref<FrameWithManifest> release()
960	{
961	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
962	COMPILE_ASSERT(sizeof(FrameWithManifest) == sizeof(JSON::Object), cannot_cast);
963
964	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
965	auto result = WTFMove(*reinterpret_cast<Ref<FrameWithManifest>*>(&jsonResult));
966	return result;
967	}
968	};
969
970	/*
971	* Synthetic constructor:
972	* Ref<FrameWithManifest> result = FrameWithManifest::create()
973	* .setFrameId(...)
974	* .setManifestURL(...)
975	* .setStatus(...)
976	* .release();
977	*/
978	static Builder<NoFieldsSet> create()
979	{
980	return Builder<NoFieldsSet>(JSON::Object::create());
981	}
982	};
983
984	} // ApplicationCache
985
986	namespace Browser {
987
988	/ Information about an extension. /
989	class Extension final : public JSON::ObjectBase {
990	public:
991	enum {
992	NoFieldsSet = `0`,
993	ExtensionIdSet = `1` << `0`,
994	NameSet = `1` << `1`,
995	AllFieldsSet = (ExtensionIdSet \| NameSet)
996	};
997
998	template<int STATE>
999	class Builder {
1000	private:
1001	RefPtr<JSON::Object> m_result;
1002
1003	template<int STEP> Builder<STATE \| STEP>& castState()
1004	{
1005	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
1006	}
1007
1008	Builder(Ref</Extension/JSON::Object>&& object)
1009	: m_result (WTFMove(object))
1010	{
1011	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1012	}
1013	friend class Extension;
1014	public:
1015
1016	Builder<STATE \| ExtensionIdSet>& setExtensionId(const String& in_extensionId)
1017	{
1018	COMPILE_ASSERT(!(STATE & ExtensionIdSet), property_extensionId_already_set);
1019	m_result ->setString("extensionId"_s, in_extensionId);
1020	return castState<ExtensionIdSet>();
1021	}
1022
1023	Builder<STATE \| NameSet>& setName(const String& in_name)
1024	{
1025	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
1026	m_result ->setString("name"_s, in_name);
1027	return castState<NameSet>();
1028	}
1029
1030	Ref<Extension> release()
1031	{
1032	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1033	COMPILE_ASSERT(sizeof(Extension) == sizeof(JSON::Object), cannot_cast);
1034
1035	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1036	auto result = WTFMove(*reinterpret_cast<Ref<Extension>*>(&jsonResult));
1037	return result;
1038	}
1039	};
1040
1041	/*
1042	* Synthetic constructor:
1043	* Ref<Extension> result = Extension::create()
1044	* .setExtensionId(...)
1045	* .setName(...)
1046	* .release();
1047	*/
1048	static Builder<NoFieldsSet> create()
1049	{
1050	return Builder<NoFieldsSet>(JSON::Object::create());
1051	}
1052	};
1053
1054	} // Browser
1055
1056	#if defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE
1057	namespace CPUProfiler {
1058
1059	/ CPU usage for an individual thread. /
1060	class ThreadInfo final : public JSON::ObjectBase {
1061	public:
1062	// Named after property name 'type' while generating ThreadInfo.
1063	enum class Type {
1064	Main = `14`,
1065	WebKit = `15`,
1066	}; // enum class Type
1067
1068	enum {
1069	NoFieldsSet = `0`,
1070	NameSet = `1` << `0`,
1071	UsageSet = `1` << `1`,
1072	AllFieldsSet = (NameSet \| UsageSet)
1073	};
1074
1075	template<int STATE>
1076	class Builder {
1077	private:
1078	RefPtr<JSON::Object> m_result;
1079
1080	template<int STEP> Builder<STATE \| STEP>& castState()
1081	{
1082	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
1083	}
1084
1085	Builder(Ref</ThreadInfo/JSON::Object>&& object)
1086	: m_result (WTFMove(object))
1087	{
1088	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1089	}
1090	friend class ThreadInfo;
1091	public:
1092
1093	Builder<STATE \| NameSet>& setName(const String& in_name)
1094	{
1095	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
1096	m_result ->setString("name"_s, in_name);
1097	return castState<NameSet>();
1098	}
1099
1100	Builder<STATE \| UsageSet>& setUsage(double in_usage)
1101	{
1102	COMPILE_ASSERT(!(STATE & UsageSet), property_usage_already_set);
1103	m_result ->setDouble("usage"_s, in_usage);
1104	return castState<UsageSet>();
1105	}
1106
1107	Ref<ThreadInfo> release()
1108	{
1109	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1110	COMPILE_ASSERT(sizeof(ThreadInfo) == sizeof(JSON::Object), cannot_cast);
1111
1112	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1113	auto result = WTFMove(*reinterpret_cast<Ref<ThreadInfo>*>(&jsonResult));
1114	return result;
1115	}
1116	};
1117
1118	/*
1119	* Synthetic constructor:
1120	* Ref<ThreadInfo> result = ThreadInfo::create()
1121	* .setName(...)
1122	* .setUsage(...)
1123	* .release();
1124	*/
1125	static Builder<NoFieldsSet> create()
1126	{
1127	return Builder<NoFieldsSet>(JSON::Object::create());
1128	}
1129
1130	void setType(Type in_opt_type)
1131	{
1132	JSON::ObjectBase::setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_opt_type));
1133	}
1134
1135	void setTargetId(const String& in_opt_targetId)
1136	{
1137	JSON::ObjectBase::setString("targetId"_s, in_opt_targetId);
1138	}
1139	};
1140
1141	class Event final : public JSON::ObjectBase {
1142	public:
1143	enum {
1144	NoFieldsSet = `0`,
1145	TimestampSet = `1` << `0`,
1146	UsageSet = `1` << `1`,
1147	AllFieldsSet = (TimestampSet \| UsageSet)
1148	};
1149
1150	template<int STATE>
1151	class Builder {
1152	private:
1153	RefPtr<JSON::Object> m_result;
1154
1155	template<int STEP> Builder<STATE \| STEP>& castState()
1156	{
1157	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
1158	}
1159
1160	Builder(Ref</Event/JSON::Object>&& object)
1161	: m_result (WTFMove(object))
1162	{
1163	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1164	}
1165	friend class Event;
1166	public:
1167
1168	Builder<STATE \| TimestampSet>& setTimestamp(double in_timestamp)
1169	{
1170	COMPILE_ASSERT(!(STATE & TimestampSet), property_timestamp_already_set);
1171	m_result ->setDouble("timestamp"_s, in_timestamp);
1172	return castState<TimestampSet>();
1173	}
1174
1175	Builder<STATE \| UsageSet>& setUsage(double in_usage)
1176	{
1177	COMPILE_ASSERT(!(STATE & UsageSet), property_usage_already_set);
1178	m_result ->setDouble("usage"_s, in_usage);
1179	return castState<UsageSet>();
1180	}
1181
1182	Ref<Event> release()
1183	{
1184	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1185	COMPILE_ASSERT(sizeof(Event) == sizeof(JSON::Object), cannot_cast);
1186
1187	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1188	auto result = WTFMove(*reinterpret_cast<Ref<Event>*>(&jsonResult));
1189	return result;
1190	}
1191	};
1192
1193	/*
1194	* Synthetic constructor:
1195	* Ref<Event> result = Event::create()
1196	* .setTimestamp(...)
1197	* .setUsage(...)
1198	* .release();
1199	*/
1200	static Builder<NoFieldsSet> create()
1201	{
1202	return Builder<NoFieldsSet>(JSON::Object::create());
1203	}
1204
1205	void setThreads(Ref<JSON::ArrayOf<Protocol::CPUProfiler::ThreadInfo>>&& in_opt_threads)
1206	{
1207	JSON::ObjectBase::setArray("threads"_s, WTFMove(in_opt_threads));
1208	}
1209	};
1210
1211	} // CPUProfiler
1212	#endif // defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE
1213
1214	namespace CSS {
1215
1216	/ This object identifies a CSS style in a unique way. /
1217	class CSSStyleId final : public JSON::ObjectBase {
1218	public:
1219	enum {
1220	NoFieldsSet = `0`,
1221	StyleSheetIdSet = `1` << `0`,
1222	OrdinalSet = `1` << `1`,
1223	AllFieldsSet = (StyleSheetIdSet \| OrdinalSet)
1224	};
1225
1226	template<int STATE>
1227	class Builder {
1228	private:
1229	RefPtr<JSON::Object> m_result;
1230
1231	template<int STEP> Builder<STATE \| STEP>& castState()
1232	{
1233	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
1234	}
1235
1236	Builder(Ref</CSSStyleId/JSON::Object>&& object)
1237	: m_result (WTFMove(object))
1238	{
1239	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1240	}
1241	friend class CSSStyleId;
1242	public:
1243
1244	Builder<STATE \| StyleSheetIdSet>& setStyleSheetId(const String& in_styleSheetId)
1245	{
1246	COMPILE_ASSERT(!(STATE & StyleSheetIdSet), property_styleSheetId_already_set);
1247	m_result ->setString("styleSheetId"_s, in_styleSheetId);
1248	return castState<StyleSheetIdSet>();
1249	}
1250
1251	Builder<STATE \| OrdinalSet>& setOrdinal(int in_ordinal)
1252	{
1253	COMPILE_ASSERT(!(STATE & OrdinalSet), property_ordinal_already_set);
1254	m_result ->setInteger("ordinal"_s, in_ordinal);
1255	return castState<OrdinalSet>();
1256	}
1257
1258	Ref<CSSStyleId> release()
1259	{
1260	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1261	COMPILE_ASSERT(sizeof(CSSStyleId) == sizeof(JSON::Object), cannot_cast);
1262
1263	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1264	auto result = WTFMove(*reinterpret_cast<Ref<CSSStyleId>*>(&jsonResult));
1265	return result;
1266	}
1267	};
1268
1269	/*
1270	* Synthetic constructor:
1271	* Ref<CSSStyleId> result = CSSStyleId::create()
1272	* .setStyleSheetId(...)
1273	* .setOrdinal(...)
1274	* .release();
1275	*/
1276	static Builder<NoFieldsSet> create()
1277	{
1278	return Builder<NoFieldsSet>(JSON::Object::create());
1279	}
1280	};
1281
1282	/* Stylesheet type: "user" for user stylesheets, "user-agent" for user-agent stylesheets, "inspector" for stylesheets created by the inspector (i.e. those holding the "via inspector" rules), "regular" for regular stylesheets. */
1283	enum class StyleSheetOrigin {
1284	User = `16`,
1285	UserAgent = `17`,
1286	Author = `18`,
1287	Inspector = `19`,
1288	}; // enum class StyleSheetOrigin
1289
1290	/ This object identifies a CSS rule in a unique way. /
1291	class CSSRuleId final : public JSON::ObjectBase {
1292	public:
1293	enum {
1294	NoFieldsSet = `0`,
1295	StyleSheetIdSet = `1` << `0`,
1296	OrdinalSet = `1` << `1`,
1297	AllFieldsSet = (StyleSheetIdSet \| OrdinalSet)
1298	};
1299
1300	template<int STATE>
1301	class Builder {
1302	private:
1303	RefPtr<JSON::Object> m_result;
1304
1305	template<int STEP> Builder<STATE \| STEP>& castState()
1306	{
1307	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
1308	}
1309
1310	Builder(Ref</CSSRuleId/JSON::Object>&& object)
1311	: m_result (WTFMove(object))
1312	{
1313	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1314	}
1315	friend class CSSRuleId;
1316	public:
1317
1318	Builder<STATE \| StyleSheetIdSet>& setStyleSheetId(const String& in_styleSheetId)
1319	{
1320	COMPILE_ASSERT(!(STATE & StyleSheetIdSet), property_styleSheetId_already_set);
1321	m_result ->setString("styleSheetId"_s, in_styleSheetId);
1322	return castState<StyleSheetIdSet>();
1323	}
1324
1325	Builder<STATE \| OrdinalSet>& setOrdinal(int in_ordinal)
1326	{
1327	COMPILE_ASSERT(!(STATE & OrdinalSet), property_ordinal_already_set);
1328	m_result ->setInteger("ordinal"_s, in_ordinal);
1329	return castState<OrdinalSet>();
1330	}
1331
1332	Ref<CSSRuleId> release()
1333	{
1334	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1335	COMPILE_ASSERT(sizeof(CSSRuleId) == sizeof(JSON::Object), cannot_cast);
1336
1337	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1338	auto result = WTFMove(*reinterpret_cast<Ref<CSSRuleId>*>(&jsonResult));
1339	return result;
1340	}
1341	};
1342
1343	/*
1344	* Synthetic constructor:
1345	* Ref<CSSRuleId> result = CSSRuleId::create()
1346	* .setStyleSheetId(...)
1347	* .setOrdinal(...)
1348	* .release();
1349	*/
1350	static Builder<NoFieldsSet> create()
1351	{
1352	return Builder<NoFieldsSet>(JSON::Object::create());
1353	}
1354	};
1355
1356	/ Pseudo-style identifier (see <code>enum PseudoId</code> in <code>RenderStyleConstants.h</code>). /
1357	enum class PseudoId {
1358	FirstLine = `20`,
1359	FirstLetter = `21`,
1360	Highlight = `22`,
1361	Marker = `23`,
1362	Before = `24`,
1363	After = `25`,
1364	Selection = `26`,
1365	Scrollbar = `27`,
1366	ScrollbarThumb = `28`,
1367	ScrollbarButton = `29`,
1368	ScrollbarTrack = `30`,
1369	ScrollbarTrackPiece = `31`,
1370	ScrollbarCorner = `32`,
1371	Resizer = `33`,
1372	}; // enum class PseudoId
1373
1374	/ CSS rule collection for a single pseudo style. /
1375	class PseudoIdMatches final : public JSON::ObjectBase {
1376	public:
1377	enum {
1378	NoFieldsSet = `0`,
1379	PseudoIdSet = `1` << `0`,
1380	MatchesSet = `1` << `1`,
1381	AllFieldsSet = (PseudoIdSet \| MatchesSet)
1382	};
1383
1384	template<int STATE>
1385	class Builder {
1386	private:
1387	RefPtr<JSON::Object> m_result;
1388
1389	template<int STEP> Builder<STATE \| STEP>& castState()
1390	{
1391	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
1392	}
1393
1394	Builder(Ref</PseudoIdMatches/JSON::Object>&& object)
1395	: m_result (WTFMove(object))
1396	{
1397	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1398	}
1399	friend class PseudoIdMatches;
1400	public:
1401
1402	Builder<STATE \| PseudoIdSet>& setPseudoId(Protocol::CSS::PseudoId in_pseudoId)
1403	{
1404	COMPILE_ASSERT(!(STATE & PseudoIdSet), property_pseudoId_already_set);
1405	m_result ->setString("pseudoId"_s, Protocol::Helpers::getEnumConstantValue(in_pseudoId));
1406	return castState<PseudoIdSet>();
1407	}
1408
1409	Builder<STATE \| MatchesSet>& setMatches(Ref<JSON::ArrayOf<Protocol::CSS::RuleMatch>>&& in_matches)
1410	{
1411	COMPILE_ASSERT(!(STATE & MatchesSet), property_matches_already_set);
1412	m_result ->setArray("matches"_s, WTFMove(in_matches));
1413	return castState<MatchesSet>();
1414	}
1415
1416	Ref<PseudoIdMatches> release()
1417	{
1418	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1419	COMPILE_ASSERT(sizeof(PseudoIdMatches) == sizeof(JSON::Object), cannot_cast);
1420
1421	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1422	auto result = WTFMove(*reinterpret_cast<Ref<PseudoIdMatches>*>(&jsonResult));
1423	return result;
1424	}
1425	};
1426
1427	/*
1428	* Synthetic constructor:
1429	* Ref<PseudoIdMatches> result = PseudoIdMatches::create()
1430	* .setPseudoId(...)
1431	* .setMatches(...)
1432	* .release();
1433	*/
1434	static Builder<NoFieldsSet> create()
1435	{
1436	return Builder<NoFieldsSet>(JSON::Object::create());
1437	}
1438	};
1439
1440	/ CSS rule collection for a single pseudo style. /
1441	class InheritedStyleEntry final : public JSON::ObjectBase {
1442	public:
1443	enum {
1444	NoFieldsSet = `0`,
1445	MatchedCSSRulesSet = `1` << `0`,
1446	AllFieldsSet = (MatchedCSSRulesSet)
1447	};
1448
1449	template<int STATE>
1450	class Builder {
1451	private:
1452	RefPtr<JSON::Object> m_result;
1453
1454	template<int STEP> Builder<STATE \| STEP>& castState()
1455	{
1456	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
1457	}
1458
1459	Builder(Ref</InheritedStyleEntry/JSON::Object>&& object)
1460	: m_result (WTFMove(object))
1461	{
1462	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1463	}
1464	friend class InheritedStyleEntry;
1465	public:
1466
1467	Builder<STATE \| MatchedCSSRulesSet>& setMatchedCSSRules(Ref<JSON::ArrayOf<Protocol::CSS::RuleMatch>>&& in_matchedCSSRules)
1468	{
1469	COMPILE_ASSERT(!(STATE & MatchedCSSRulesSet), property_matchedCSSRules_already_set);
1470	m_result ->setArray("matchedCSSRules"_s, WTFMove(in_matchedCSSRules));
1471	return castState<MatchedCSSRulesSet>();
1472	}
1473
1474	Ref<InheritedStyleEntry> release()
1475	{
1476	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1477	COMPILE_ASSERT(sizeof(InheritedStyleEntry) == sizeof(JSON::Object), cannot_cast);
1478
1479	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1480	auto result = WTFMove(*reinterpret_cast<Ref<InheritedStyleEntry>*>(&jsonResult));
1481	return result;
1482	}
1483	};
1484
1485	/*
1486	* Synthetic constructor:
1487	* Ref<InheritedStyleEntry> result = InheritedStyleEntry::create()
1488	* .setMatchedCSSRules(...)
1489	* .release();
1490	*/
1491	static Builder<NoFieldsSet> create()
1492	{
1493	return Builder<NoFieldsSet>(JSON::Object::create());
1494	}
1495
1496	void setInlineStyle(Ref<Protocol::CSS::CSSStyle>&& in_opt_inlineStyle)
1497	{
1498	JSON::ObjectBase::setObject("inlineStyle"_s, WTFMove(in_opt_inlineStyle));
1499	}
1500	};
1501
1502	/ Match data for a CSS rule. /
1503	class RuleMatch final : public JSON::ObjectBase {
1504	public:
1505	enum {
1506	NoFieldsSet = `0`,
1507	RuleSet = `1` << `0`,
1508	MatchingSelectorsSet = `1` << `1`,
1509	AllFieldsSet = (RuleSet \| MatchingSelectorsSet)
1510	};
1511
1512	template<int STATE>
1513	class Builder {
1514	private:
1515	RefPtr<JSON::Object> m_result;
1516
1517	template<int STEP> Builder<STATE \| STEP>& castState()
1518	{
1519	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
1520	}
1521
1522	Builder(Ref</RuleMatch/JSON::Object>&& object)
1523	: m_result (WTFMove(object))
1524	{
1525	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1526	}
1527	friend class RuleMatch;
1528	public:
1529
1530	Builder<STATE \| RuleSet>& setRule(Ref<Protocol::CSS::CSSRule>&& in_rule)
1531	{
1532	COMPILE_ASSERT(!(STATE & RuleSet), property_rule_already_set);
1533	m_result ->setObject("rule"_s, WTFMove(in_rule));
1534	return castState<RuleSet>();
1535	}
1536
1537	Builder<STATE \| MatchingSelectorsSet>& setMatchingSelectors(Ref<JSON::ArrayOf<int>>&& in_matchingSelectors)
1538	{
1539	COMPILE_ASSERT(!(STATE & MatchingSelectorsSet), property_matchingSelectors_already_set);
1540	m_result ->setArray("matchingSelectors"_s, WTFMove(in_matchingSelectors));
1541	return castState<MatchingSelectorsSet>();
1542	}
1543
1544	Ref<RuleMatch> release()
1545	{
1546	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1547	COMPILE_ASSERT(sizeof(RuleMatch) == sizeof(JSON::Object), cannot_cast);
1548
1549	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1550	auto result = WTFMove(*reinterpret_cast<Ref<RuleMatch>*>(&jsonResult));
1551	return result;
1552	}
1553	};
1554
1555	/*
1556	* Synthetic constructor:
1557	* Ref<RuleMatch> result = RuleMatch::create()
1558	* .setRule(...)
1559	* .setMatchingSelectors(...)
1560	* .release();
1561	*/
1562	static Builder<NoFieldsSet> create()
1563	{
1564	return Builder<NoFieldsSet>(JSON::Object::create());
1565	}
1566	};
1567
1568	/ CSS selector. /
1569	class CSSSelector final : public JSON::ObjectBase {
1570	public:
1571	enum {
1572	NoFieldsSet = `0`,
1573	TextSet = `1` << `0`,
1574	AllFieldsSet = (TextSet)
1575	};
1576
1577	template<int STATE>
1578	class Builder {
1579	private:
1580	RefPtr<JSON::Object> m_result;
1581
1582	template<int STEP> Builder<STATE \| STEP>& castState()
1583	{
1584	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
1585	}
1586
1587	Builder(Ref</CSSSelector/JSON::Object>&& object)
1588	: m_result (WTFMove(object))
1589	{
1590	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1591	}
1592	friend class CSSSelector;
1593	public:
1594
1595	Builder<STATE \| TextSet>& setText(const String& in_text)
1596	{
1597	COMPILE_ASSERT(!(STATE & TextSet), property_text_already_set);
1598	m_result ->setString("text"_s, in_text);
1599	return castState<TextSet>();
1600	}
1601
1602	Ref<CSSSelector> release()
1603	{
1604	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1605	COMPILE_ASSERT(sizeof(CSSSelector) == sizeof(JSON::Object), cannot_cast);
1606
1607	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1608	auto result = WTFMove(*reinterpret_cast<Ref<CSSSelector>*>(&jsonResult));
1609	return result;
1610	}
1611	};
1612
1613	/*
1614	* Synthetic constructor:
1615	* Ref<CSSSelector> result = CSSSelector::create()
1616	* .setText(...)
1617	* .release();
1618	*/
1619	static Builder<NoFieldsSet> create()
1620	{
1621	return Builder<NoFieldsSet>(JSON::Object::create());
1622	}
1623
1624	void setSpecificity(Ref<JSON::ArrayOf<int>>&& in_opt_specificity)
1625	{
1626	JSON::ObjectBase::setArray("specificity"_s, WTFMove(in_opt_specificity));
1627	}
1628
1629	void setDynamic(bool in_opt_dynamic)
1630	{
1631	JSON::ObjectBase::setBoolean("dynamic"_s, in_opt_dynamic);
1632	}
1633	};
1634
1635	/ Selector list data. /
1636	class SelectorList final : public JSON::ObjectBase {
1637	public:
1638	enum {
1639	NoFieldsSet = `0`,
1640	SelectorsSet = `1` << `0`,
1641	TextSet = `1` << `1`,
1642	AllFieldsSet = (SelectorsSet \| TextSet)
1643	};
1644
1645	template<int STATE>
1646	class Builder {
1647	private:
1648	RefPtr<JSON::Object> m_result;
1649
1650	template<int STEP> Builder<STATE \| STEP>& castState()
1651	{
1652	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
1653	}
1654
1655	Builder(Ref</SelectorList/JSON::Object>&& object)
1656	: m_result (WTFMove(object))
1657	{
1658	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1659	}
1660	friend class SelectorList;
1661	public:
1662
1663	Builder<STATE \| SelectorsSet>& setSelectors(Ref<JSON::ArrayOf<Protocol::CSS::CSSSelector>>&& in_selectors)
1664	{
1665	COMPILE_ASSERT(!(STATE & SelectorsSet), property_selectors_already_set);
1666	m_result ->setArray("selectors"_s, WTFMove(in_selectors));
1667	return castState<SelectorsSet>();
1668	}
1669
1670	Builder<STATE \| TextSet>& setText(const String& in_text)
1671	{
1672	COMPILE_ASSERT(!(STATE & TextSet), property_text_already_set);
1673	m_result ->setString("text"_s, in_text);
1674	return castState<TextSet>();
1675	}
1676
1677	Ref<SelectorList> release()
1678	{
1679	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1680	COMPILE_ASSERT(sizeof(SelectorList) == sizeof(JSON::Object), cannot_cast);
1681
1682	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1683	auto result = WTFMove(*reinterpret_cast<Ref<SelectorList>*>(&jsonResult));
1684	return result;
1685	}
1686	};
1687
1688	/*
1689	* Synthetic constructor:
1690	* Ref<SelectorList> result = SelectorList::create()
1691	* .setSelectors(...)
1692	* .setText(...)
1693	* .release();
1694	*/
1695	static Builder<NoFieldsSet> create()
1696	{
1697	return Builder<NoFieldsSet>(JSON::Object::create());
1698	}
1699
1700	void setRange(Ref<Protocol::CSS::SourceRange>&& in_opt_range)
1701	{
1702	JSON::ObjectBase::setObject("range"_s, WTFMove(in_opt_range));
1703	}
1704	};
1705
1706	/ CSS style information for a DOM style attribute. /
1707	class CSSStyleAttribute final : public JSON::ObjectBase {
1708	public:
1709	enum {
1710	NoFieldsSet = `0`,
1711	NameSet = `1` << `0`,
1712	StyleSet = `1` << `1`,
1713	AllFieldsSet = (NameSet \| StyleSet)
1714	};
1715
1716	template<int STATE>
1717	class Builder {
1718	private:
1719	RefPtr<JSON::Object> m_result;
1720
1721	template<int STEP> Builder<STATE \| STEP>& castState()
1722	{
1723	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
1724	}
1725
1726	Builder(Ref</CSSStyleAttribute/JSON::Object>&& object)
1727	: m_result (WTFMove(object))
1728	{
1729	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1730	}
1731	friend class CSSStyleAttribute;
1732	public:
1733
1734	Builder<STATE \| NameSet>& setName(const String& in_name)
1735	{
1736	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
1737	m_result ->setString("name"_s, in_name);
1738	return castState<NameSet>();
1739	}
1740
1741	Builder<STATE \| StyleSet>& setStyle(Ref<Protocol::CSS::CSSStyle>&& in_style)
1742	{
1743	COMPILE_ASSERT(!(STATE & StyleSet), property_style_already_set);
1744	m_result ->setObject("style"_s, WTFMove(in_style));
1745	return castState<StyleSet>();
1746	}
1747
1748	Ref<CSSStyleAttribute> release()
1749	{
1750	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1751	COMPILE_ASSERT(sizeof(CSSStyleAttribute) == sizeof(JSON::Object), cannot_cast);
1752
1753	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1754	auto result = WTFMove(*reinterpret_cast<Ref<CSSStyleAttribute>*>(&jsonResult));
1755	return result;
1756	}
1757	};
1758
1759	/*
1760	* Synthetic constructor:
1761	* Ref<CSSStyleAttribute> result = CSSStyleAttribute::create()
1762	* .setName(...)
1763	* .setStyle(...)
1764	* .release();
1765	*/
1766	static Builder<NoFieldsSet> create()
1767	{
1768	return Builder<NoFieldsSet>(JSON::Object::create());
1769	}
1770	};
1771
1772	/ CSS stylesheet meta-information. /
1773	class CSSStyleSheetHeader final : public JSON::ObjectBase {
1774	public:
1775	enum {
1776	NoFieldsSet = `0`,
1777	StyleSheetIdSet = `1` << `0`,
1778	FrameIdSet = `1` << `1`,
1779	SourceURLSet = `1` << `2`,
1780	OriginSet = `1` << `3`,
1781	TitleSet = `1` << `4`,
1782	DisabledSet = `1` << `5`,
1783	IsInlineSet = `1` << `6`,
1784	StartLineSet = `1` << `7`,
1785	StartColumnSet = `1` << `8`,
1786	AllFieldsSet = (StyleSheetIdSet \| FrameIdSet \| SourceURLSet \| OriginSet \| TitleSet \| DisabledSet \| IsInlineSet \| StartLineSet \| StartColumnSet)
1787	};
1788
1789	template<int STATE>
1790	class Builder {
1791	private:
1792	RefPtr<JSON::Object> m_result;
1793
1794	template<int STEP> Builder<STATE \| STEP>& castState()
1795	{
1796	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
1797	}
1798
1799	Builder(Ref</CSSStyleSheetHeader/JSON::Object>&& object)
1800	: m_result (WTFMove(object))
1801	{
1802	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1803	}
1804	friend class CSSStyleSheetHeader;
1805	public:
1806
1807	Builder<STATE \| StyleSheetIdSet>& setStyleSheetId(const String& in_styleSheetId)
1808	{
1809	COMPILE_ASSERT(!(STATE & StyleSheetIdSet), property_styleSheetId_already_set);
1810	m_result ->setString("styleSheetId"_s, in_styleSheetId);
1811	return castState<StyleSheetIdSet>();
1812	}
1813
1814	Builder<STATE \| FrameIdSet>& setFrameId(const String& in_frameId)
1815	{
1816	COMPILE_ASSERT(!(STATE & FrameIdSet), property_frameId_already_set);
1817	m_result ->setString("frameId"_s, in_frameId);
1818	return castState<FrameIdSet>();
1819	}
1820
1821	Builder<STATE \| SourceURLSet>& setSourceURL(const String& in_sourceURL)
1822	{
1823	COMPILE_ASSERT(!(STATE & SourceURLSet), property_sourceURL_already_set);
1824	m_result ->setString("sourceURL"_s, in_sourceURL);
1825	return castState<SourceURLSet>();
1826	}
1827
1828	Builder<STATE \| OriginSet>& setOrigin(Protocol::CSS::StyleSheetOrigin in_origin)
1829	{
1830	COMPILE_ASSERT(!(STATE & OriginSet), property_origin_already_set);
1831	m_result ->setString("origin"_s, Protocol::Helpers::getEnumConstantValue(in_origin));
1832	return castState<OriginSet>();
1833	}
1834
1835	Builder<STATE \| TitleSet>& setTitle(const String& in_title)
1836	{
1837	COMPILE_ASSERT(!(STATE & TitleSet), property_title_already_set);
1838	m_result ->setString("title"_s, in_title);
1839	return castState<TitleSet>();
1840	}
1841
1842	Builder<STATE \| DisabledSet>& setDisabled(bool in_disabled)
1843	{
1844	COMPILE_ASSERT(!(STATE & DisabledSet), property_disabled_already_set);
1845	m_result ->setBoolean("disabled"_s, in_disabled);
1846	return castState<DisabledSet>();
1847	}
1848
1849	Builder<STATE \| IsInlineSet>& setIsInline(bool in_isInline)
1850	{
1851	COMPILE_ASSERT(!(STATE & IsInlineSet), property_isInline_already_set);
1852	m_result ->setBoolean("isInline"_s, in_isInline);
1853	return castState<IsInlineSet>();
1854	}
1855
1856	Builder<STATE \| StartLineSet>& setStartLine(double in_startLine)
1857	{
1858	COMPILE_ASSERT(!(STATE & StartLineSet), property_startLine_already_set);
1859	m_result ->setDouble("startLine"_s, in_startLine);
1860	return castState<StartLineSet>();
1861	}
1862
1863	Builder<STATE \| StartColumnSet>& setStartColumn(double in_startColumn)
1864	{
1865	COMPILE_ASSERT(!(STATE & StartColumnSet), property_startColumn_already_set);
1866	m_result ->setDouble("startColumn"_s, in_startColumn);
1867	return castState<StartColumnSet>();
1868	}
1869
1870	Ref<CSSStyleSheetHeader> release()
1871	{
1872	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1873	COMPILE_ASSERT(sizeof(CSSStyleSheetHeader) == sizeof(JSON::Object), cannot_cast);
1874
1875	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1876	auto result = WTFMove(*reinterpret_cast<Ref<CSSStyleSheetHeader>*>(&jsonResult));
1877	return result;
1878	}
1879	};
1880
1881	/*
1882	* Synthetic constructor:
1883	* Ref<CSSStyleSheetHeader> result = CSSStyleSheetHeader::create()
1884	* .setStyleSheetId(...)
1885	* .setFrameId(...)
1886	* .setSourceURL(...)
1887	* .setOrigin(...)
1888	* .setTitle(...)
1889	* .setDisabled(...)
1890	* .setIsInline(...)
1891	* .setStartLine(...)
1892	* .setStartColumn(...)
1893	* .release();
1894	*/
1895	static Builder<NoFieldsSet> create()
1896	{
1897	return Builder<NoFieldsSet>(JSON::Object::create());
1898	}
1899	};
1900
1901	/ CSS stylesheet contents. /
1902	class CSSStyleSheetBody final : public JSON::ObjectBase {
1903	public:
1904	enum {
1905	NoFieldsSet = `0`,
1906	StyleSheetIdSet = `1` << `0`,
1907	RulesSet = `1` << `1`,
1908	AllFieldsSet = (StyleSheetIdSet \| RulesSet)
1909	};
1910
1911	template<int STATE>
1912	class Builder {
1913	private:
1914	RefPtr<JSON::Object> m_result;
1915
1916	template<int STEP> Builder<STATE \| STEP>& castState()
1917	{
1918	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
1919	}
1920
1921	Builder(Ref</CSSStyleSheetBody/JSON::Object>&& object)
1922	: m_result (WTFMove(object))
1923	{
1924	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1925	}
1926	friend class CSSStyleSheetBody;
1927	public:
1928
1929	Builder<STATE \| StyleSheetIdSet>& setStyleSheetId(const String& in_styleSheetId)
1930	{
1931	COMPILE_ASSERT(!(STATE & StyleSheetIdSet), property_styleSheetId_already_set);
1932	m_result ->setString("styleSheetId"_s, in_styleSheetId);
1933	return castState<StyleSheetIdSet>();
1934	}
1935
1936	Builder<STATE \| RulesSet>& setRules(Ref<JSON::ArrayOf<Protocol::CSS::CSSRule>>&& in_rules)
1937	{
1938	COMPILE_ASSERT(!(STATE & RulesSet), property_rules_already_set);
1939	m_result ->setArray("rules"_s, WTFMove(in_rules));
1940	return castState<RulesSet>();
1941	}
1942
1943	Ref<CSSStyleSheetBody> release()
1944	{
1945	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1946	COMPILE_ASSERT(sizeof(CSSStyleSheetBody) == sizeof(JSON::Object), cannot_cast);
1947
1948	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1949	auto result = WTFMove(*reinterpret_cast<Ref<CSSStyleSheetBody>*>(&jsonResult));
1950	return result;
1951	}
1952	};
1953
1954	/*
1955	* Synthetic constructor:
1956	* Ref<CSSStyleSheetBody> result = CSSStyleSheetBody::create()
1957	* .setStyleSheetId(...)
1958	* .setRules(...)
1959	* .release();
1960	*/
1961	static Builder<NoFieldsSet> create()
1962	{
1963	return Builder<NoFieldsSet>(JSON::Object::create());
1964	}
1965
1966	void setText(const String& in_opt_text)
1967	{
1968	JSON::ObjectBase::setString("text"_s, in_opt_text);
1969	}
1970	};
1971
1972	/ CSS rule representation. /
1973	class CSSRule final : public JSON::ObjectBase {
1974	public:
1975	enum {
1976	NoFieldsSet = `0`,
1977	SelectorListSet = `1` << `0`,
1978	SourceLineSet = `1` << `1`,
1979	OriginSet = `1` << `2`,
1980	StyleSet = `1` << `3`,
1981	AllFieldsSet = (SelectorListSet \| SourceLineSet \| OriginSet \| StyleSet)
1982	};
1983
1984	template<int STATE>
1985	class Builder {
1986	private:
1987	RefPtr<JSON::Object> m_result;
1988
1989	template<int STEP> Builder<STATE \| STEP>& castState()
1990	{
1991	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
1992	}
1993
1994	Builder(Ref</CSSRule/JSON::Object>&& object)
1995	: m_result (WTFMove(object))
1996	{
1997	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1998	}
1999	friend class CSSRule;
2000	public:
2001
2002	Builder<STATE \| SelectorListSet>& setSelectorList(Ref<Protocol::CSS::SelectorList>&& in_selectorList)
2003	{
2004	COMPILE_ASSERT(!(STATE & SelectorListSet), property_selectorList_already_set);
2005	m_result ->setObject("selectorList"_s, WTFMove(in_selectorList));
2006	return castState<SelectorListSet>();
2007	}
2008
2009	Builder<STATE \| SourceLineSet>& setSourceLine(int in_sourceLine)
2010	{
2011	COMPILE_ASSERT(!(STATE & SourceLineSet), property_sourceLine_already_set);
2012	m_result ->setInteger("sourceLine"_s, in_sourceLine);
2013	return castState<SourceLineSet>();
2014	}
2015
2016	Builder<STATE \| OriginSet>& setOrigin(Protocol::CSS::StyleSheetOrigin in_origin)
2017	{
2018	COMPILE_ASSERT(!(STATE & OriginSet), property_origin_already_set);
2019	m_result ->setString("origin"_s, Protocol::Helpers::getEnumConstantValue(in_origin));
2020	return castState<OriginSet>();
2021	}
2022
2023	Builder<STATE \| StyleSet>& setStyle(Ref<Protocol::CSS::CSSStyle>&& in_style)
2024	{
2025	COMPILE_ASSERT(!(STATE & StyleSet), property_style_already_set);
2026	m_result ->setObject("style"_s, WTFMove(in_style));
2027	return castState<StyleSet>();
2028	}
2029
2030	Ref<CSSRule> release()
2031	{
2032	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2033	COMPILE_ASSERT(sizeof(CSSRule) == sizeof(JSON::Object), cannot_cast);
2034
2035	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2036	auto result = WTFMove(*reinterpret_cast<Ref<CSSRule>*>(&jsonResult));
2037	return result;
2038	}
2039	};
2040
2041	/*
2042	* Synthetic constructor:
2043	* Ref<CSSRule> result = CSSRule::create()
2044	* .setSelectorList(...)
2045	* .setSourceLine(...)
2046	* .setOrigin(...)
2047	* .setStyle(...)
2048	* .release();
2049	*/
2050	static Builder<NoFieldsSet> create()
2051	{
2052	return Builder<NoFieldsSet>(JSON::Object::create());
2053	}
2054
2055	void setRuleId(Ref<Protocol::CSS::CSSRuleId>&& in_opt_ruleId)
2056	{
2057	JSON::ObjectBase::setObject("ruleId"_s, WTFMove(in_opt_ruleId));
2058	}
2059
2060	void setSourceURL(const String& in_opt_sourceURL)
2061	{
2062	JSON::ObjectBase::setString("sourceURL"_s, in_opt_sourceURL);
2063	}
2064
2065	void setGroupings(Ref<JSON::ArrayOf<Protocol::CSS::Grouping>>&& in_opt_groupings)
2066	{
2067	JSON::ObjectBase::setArray("groupings"_s, WTFMove(in_opt_groupings));
2068	}
2069	};
2070
2071	/ Text range within a resource. /
2072	class SourceRange final : public JSON::ObjectBase {
2073	public:
2074	enum {
2075	NoFieldsSet = `0`,
2076	StartLineSet = `1` << `0`,
2077	StartColumnSet = `1` << `1`,
2078	EndLineSet = `1` << `2`,
2079	EndColumnSet = `1` << `3`,
2080	AllFieldsSet = (StartLineSet \| StartColumnSet \| EndLineSet \| EndColumnSet)
2081	};
2082
2083	template<int STATE>
2084	class Builder {
2085	private:
2086	RefPtr<JSON::Object> m_result;
2087
2088	template<int STEP> Builder<STATE \| STEP>& castState()
2089	{
2090	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
2091	}
2092
2093	Builder(Ref</SourceRange/JSON::Object>&& object)
2094	: m_result (WTFMove(object))
2095	{
2096	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2097	}
2098	friend class SourceRange;
2099	public:
2100
2101	Builder<STATE \| StartLineSet>& setStartLine(int in_startLine)
2102	{
2103	COMPILE_ASSERT(!(STATE & StartLineSet), property_startLine_already_set);
2104	m_result ->setInteger("startLine"_s, in_startLine);
2105	return castState<StartLineSet>();
2106	}
2107
2108	Builder<STATE \| StartColumnSet>& setStartColumn(int in_startColumn)
2109	{
2110	COMPILE_ASSERT(!(STATE & StartColumnSet), property_startColumn_already_set);
2111	m_result ->setInteger("startColumn"_s, in_startColumn);
2112	return castState<StartColumnSet>();
2113	}
2114
2115	Builder<STATE \| EndLineSet>& setEndLine(int in_endLine)
2116	{
2117	COMPILE_ASSERT(!(STATE & EndLineSet), property_endLine_already_set);
2118	m_result ->setInteger("endLine"_s, in_endLine);
2119	return castState<EndLineSet>();
2120	}
2121
2122	Builder<STATE \| EndColumnSet>& setEndColumn(int in_endColumn)
2123	{
2124	COMPILE_ASSERT(!(STATE & EndColumnSet), property_endColumn_already_set);
2125	m_result ->setInteger("endColumn"_s, in_endColumn);
2126	return castState<EndColumnSet>();
2127	}
2128
2129	Ref<SourceRange> release()
2130	{
2131	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2132	COMPILE_ASSERT(sizeof(SourceRange) == sizeof(JSON::Object), cannot_cast);
2133
2134	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2135	auto result = WTFMove(*reinterpret_cast<Ref<SourceRange>*>(&jsonResult));
2136	return result;
2137	}
2138	};
2139
2140	/*
2141	* Synthetic constructor:
2142	* Ref<SourceRange> result = SourceRange::create()
2143	* .setStartLine(...)
2144	* .setStartColumn(...)
2145	* .setEndLine(...)
2146	* .setEndColumn(...)
2147	* .release();
2148	*/
2149	static Builder<NoFieldsSet> create()
2150	{
2151	return Builder<NoFieldsSet>(JSON::Object::create());
2152	}
2153	};
2154
2155	class ShorthandEntry final : public JSON::ObjectBase {
2156	public:
2157	enum {
2158	NoFieldsSet = `0`,
2159	NameSet = `1` << `0`,
2160	ValueSet = `1` << `1`,
2161	AllFieldsSet = (NameSet \| ValueSet)
2162	};
2163
2164	template<int STATE>
2165	class Builder {
2166	private:
2167	RefPtr<JSON::Object> m_result;
2168
2169	template<int STEP> Builder<STATE \| STEP>& castState()
2170	{
2171	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
2172	}
2173
2174	Builder(Ref</ShorthandEntry/JSON::Object>&& object)
2175	: m_result (WTFMove(object))
2176	{
2177	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2178	}
2179	friend class ShorthandEntry;
2180	public:
2181
2182	Builder<STATE \| NameSet>& setName(const String& in_name)
2183	{
2184	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
2185	m_result ->setString("name"_s, in_name);
2186	return castState<NameSet>();
2187	}
2188
2189	Builder<STATE \| ValueSet>& setValue(const String& in_value)
2190	{
2191	COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set);
2192	m_result ->setString("value"_s, in_value);
2193	return castState<ValueSet>();
2194	}
2195
2196	Ref<ShorthandEntry> release()
2197	{
2198	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2199	COMPILE_ASSERT(sizeof(ShorthandEntry) == sizeof(JSON::Object), cannot_cast);
2200
2201	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2202	auto result = WTFMove(*reinterpret_cast<Ref<ShorthandEntry>*>(&jsonResult));
2203	return result;
2204	}
2205	};
2206
2207	/*
2208	* Synthetic constructor:
2209	* Ref<ShorthandEntry> result = ShorthandEntry::create()
2210	* .setName(...)
2211	* .setValue(...)
2212	* .release();
2213	*/
2214	static Builder<NoFieldsSet> create()
2215	{
2216	return Builder<NoFieldsSet>(JSON::Object::create());
2217	}
2218	};
2219
2220	class CSSPropertyInfo final : public JSON::ObjectBase {
2221	public:
2222	enum {
2223	NoFieldsSet = `0`,
2224	NameSet = `1` << `0`,
2225	AllFieldsSet = (NameSet)
2226	};
2227
2228	template<int STATE>
2229	class Builder {
2230	private:
2231	RefPtr<JSON::Object> m_result;
2232
2233	template<int STEP> Builder<STATE \| STEP>& castState()
2234	{
2235	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
2236	}
2237
2238	Builder(Ref</CSSPropertyInfo/JSON::Object>&& object)
2239	: m_result (WTFMove(object))
2240	{
2241	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2242	}
2243	friend class CSSPropertyInfo;
2244	public:
2245
2246	Builder<STATE \| NameSet>& setName(const String& in_name)
2247	{
2248	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
2249	m_result ->setString("name"_s, in_name);
2250	return castState<NameSet>();
2251	}
2252
2253	Ref<CSSPropertyInfo> release()
2254	{
2255	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2256	COMPILE_ASSERT(sizeof(CSSPropertyInfo) == sizeof(JSON::Object), cannot_cast);
2257
2258	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2259	auto result = WTFMove(*reinterpret_cast<Ref<CSSPropertyInfo>*>(&jsonResult));
2260	return result;
2261	}
2262	};
2263
2264	/*
2265	* Synthetic constructor:
2266	* Ref<CSSPropertyInfo> result = CSSPropertyInfo::create()
2267	* .setName(...)
2268	* .release();
2269	*/
2270	static Builder<NoFieldsSet> create()
2271	{
2272	return Builder<NoFieldsSet>(JSON::Object::create());
2273	}
2274
2275	void setAliases(Ref<JSON::ArrayOf<String>>&& in_opt_aliases)
2276	{
2277	JSON::ObjectBase::setArray("aliases"_s, WTFMove(in_opt_aliases));
2278	}
2279
2280	void setLonghands(Ref<JSON::ArrayOf<String>>&& in_opt_longhands)
2281	{
2282	JSON::ObjectBase::setArray("longhands"_s, WTFMove(in_opt_longhands));
2283	}
2284
2285	void setValues(Ref<JSON::ArrayOf<String>>&& in_opt_values)
2286	{
2287	JSON::ObjectBase::setArray("values"_s, WTFMove(in_opt_values));
2288	}
2289
2290	void setInherited(bool in_opt_inherited)
2291	{
2292	JSON::ObjectBase::setBoolean("inherited"_s, in_opt_inherited);
2293	}
2294	};
2295
2296	class CSSComputedStyleProperty final : public JSON::ObjectBase {
2297	public:
2298	enum {
2299	NoFieldsSet = `0`,
2300	NameSet = `1` << `0`,
2301	ValueSet = `1` << `1`,
2302	AllFieldsSet = (NameSet \| ValueSet)
2303	};
2304
2305	template<int STATE>
2306	class Builder {
2307	private:
2308	RefPtr<JSON::Object> m_result;
2309
2310	template<int STEP> Builder<STATE \| STEP>& castState()
2311	{
2312	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
2313	}
2314
2315	Builder(Ref</CSSComputedStyleProperty/JSON::Object>&& object)
2316	: m_result (WTFMove(object))
2317	{
2318	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2319	}
2320	friend class CSSComputedStyleProperty;
2321	public:
2322
2323	Builder<STATE \| NameSet>& setName(const String& in_name)
2324	{
2325	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
2326	m_result ->setString("name"_s, in_name);
2327	return castState<NameSet>();
2328	}
2329
2330	Builder<STATE \| ValueSet>& setValue(const String& in_value)
2331	{
2332	COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set);
2333	m_result ->setString("value"_s, in_value);
2334	return castState<ValueSet>();
2335	}
2336
2337	Ref<CSSComputedStyleProperty> release()
2338	{
2339	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2340	COMPILE_ASSERT(sizeof(CSSComputedStyleProperty) == sizeof(JSON::Object), cannot_cast);
2341
2342	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2343	auto result = WTFMove(*reinterpret_cast<Ref<CSSComputedStyleProperty>*>(&jsonResult));
2344	return result;
2345	}
2346	};
2347
2348	/*
2349	* Synthetic constructor:
2350	* Ref<CSSComputedStyleProperty> result = CSSComputedStyleProperty::create()
2351	* .setName(...)
2352	* .setValue(...)
2353	* .release();
2354	*/
2355	static Builder<NoFieldsSet> create()
2356	{
2357	return Builder<NoFieldsSet>(JSON::Object::create());
2358	}
2359	};
2360
2361	/ CSS style representation. /
2362	class CSSStyle final : public JSON::ObjectBase {
2363	public:
2364	enum {
2365	NoFieldsSet = `0`,
2366	CssPropertiesSet = `1` << `0`,
2367	ShorthandEntriesSet = `1` << `1`,
2368	AllFieldsSet = (CssPropertiesSet \| ShorthandEntriesSet)
2369	};
2370
2371	template<int STATE>
2372	class Builder {
2373	private:
2374	RefPtr<JSON::Object> m_result;
2375
2376	template<int STEP> Builder<STATE \| STEP>& castState()
2377	{
2378	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
2379	}
2380
2381	Builder(Ref</CSSStyle/JSON::Object>&& object)
2382	: m_result (WTFMove(object))
2383	{
2384	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2385	}
2386	friend class CSSStyle;
2387	public:
2388
2389	Builder<STATE \| CssPropertiesSet>& setCssProperties(Ref<JSON::ArrayOf<Protocol::CSS::CSSProperty>>&& in_cssProperties)
2390	{
2391	COMPILE_ASSERT(!(STATE & CssPropertiesSet), property_cssProperties_already_set);
2392	m_result ->setArray("cssProperties"_s, WTFMove(in_cssProperties));
2393	return castState<CssPropertiesSet>();
2394	}
2395
2396	Builder<STATE \| ShorthandEntriesSet>& setShorthandEntries(Ref<JSON::ArrayOf<Protocol::CSS::ShorthandEntry>>&& in_shorthandEntries)
2397	{
2398	COMPILE_ASSERT(!(STATE & ShorthandEntriesSet), property_shorthandEntries_already_set);
2399	m_result ->setArray("shorthandEntries"_s, WTFMove(in_shorthandEntries));
2400	return castState<ShorthandEntriesSet>();
2401	}
2402
2403	Ref<CSSStyle> release()
2404	{
2405	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2406	COMPILE_ASSERT(sizeof(CSSStyle) == sizeof(JSON::Object), cannot_cast);
2407
2408	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2409	auto result = WTFMove(*reinterpret_cast<Ref<CSSStyle>*>(&jsonResult));
2410	return result;
2411	}
2412	};
2413
2414	/*
2415	* Synthetic constructor:
2416	* Ref<CSSStyle> result = CSSStyle::create()
2417	* .setCssProperties(...)
2418	* .setShorthandEntries(...)
2419	* .release();
2420	*/
2421	static Builder<NoFieldsSet> create()
2422	{
2423	return Builder<NoFieldsSet>(JSON::Object::create());
2424	}
2425
2426	void setStyleId(Ref<Protocol::CSS::CSSStyleId>&& in_opt_styleId)
2427	{
2428	JSON::ObjectBase::setObject("styleId"_s, WTFMove(in_opt_styleId));
2429	}
2430
2431	void setCssText(const String& in_opt_cssText)
2432	{
2433	JSON::ObjectBase::setString("cssText"_s, in_opt_cssText);
2434	}
2435
2436	void setRange(Ref<Protocol::CSS::SourceRange>&& in_opt_range)
2437	{
2438	JSON::ObjectBase::setObject("range"_s, WTFMove(in_opt_range));
2439	}
2440
2441	void setWidth(const String& in_opt_width)
2442	{
2443	JSON::ObjectBase::setString("width"_s, in_opt_width);
2444	}
2445
2446	void setHeight(const String& in_opt_height)
2447	{
2448	JSON::ObjectBase::setString("height"_s, in_opt_height);
2449	}
2450	};
2451
2452	/* The property status: "active" if the property is effective in the style, "inactive" if the property is overridden by a same-named property in this style later on, "disabled" if the property is disabled by the user, "style" (implied if absent) if the property is reported by the browser rather than by the CSS source parser. */
2453	enum class CSSPropertyStatus {
2454	Active = `2`,
2455	Inactive = `34`,
2456	Disabled = `35`,
2457	Style = `36`,
2458	}; // enum class CSSPropertyStatus
2459
2460	/ CSS style effective visual dimensions and source offsets. /
2461	class CSSProperty final : public JSON::Object {
2462	public:
2463	enum {
2464	NoFieldsSet = `0`,
2465	NameSet = `1` << `0`,
2466	ValueSet = `1` << `1`,
2467	AllFieldsSet = (NameSet \| ValueSet)
2468	};
2469
2470	template<int STATE>
2471	class Builder {
2472	private:
2473	RefPtr<JSON::Object> m_result;
2474
2475	template<int STEP> Builder<STATE \| STEP>& castState()
2476	{
2477	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
2478	}
2479
2480	Builder(Ref</CSSProperty/JSON::Object>&& object)
2481	: m_result (WTFMove(object))
2482	{
2483	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2484	}
2485	friend class CSSProperty;
2486	public:
2487
2488	Builder<STATE \| NameSet>& setName(const String& in_name)
2489	{
2490	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
2491	m_result ->setString("name"_s, in_name);
2492	return castState<NameSet>();
2493	}
2494
2495	Builder<STATE \| ValueSet>& setValue(const String& in_value)
2496	{
2497	COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set);
2498	m_result ->setString("value"_s, in_value);
2499	return castState<ValueSet>();
2500	}
2501
2502	Ref<CSSProperty> release()
2503	{
2504	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2505	COMPILE_ASSERT(sizeof(CSSProperty) == sizeof(JSON::Object), cannot_cast);
2506
2507	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2508	auto result = WTFMove(*reinterpret_cast<Ref<CSSProperty>*>(&jsonResult));
2509	return result;
2510	}
2511	};
2512
2513	/*
2514	* Synthetic constructor:
2515	* Ref<CSSProperty> result = CSSProperty::create()
2516	* .setName(...)
2517	* .setValue(...)
2518	* .release();
2519	*/
2520	static Builder<NoFieldsSet> create()
2521	{
2522	return Builder<NoFieldsSet>(JSON::Object::create());
2523	}
2524
2525	void setPriority(const String& in_opt_priority)
2526	{
2527	JSON::ObjectBase::setString("priority"_s, in_opt_priority);
2528	}
2529
2530	void setImplicit(bool in_opt_implicit)
2531	{
2532	JSON::ObjectBase::setBoolean("implicit"_s, in_opt_implicit);
2533	}
2534
2535	void setText(const String& in_opt_text)
2536	{
2537	JSON::ObjectBase::setString("text"_s, in_opt_text);
2538	}
2539
2540	void setParsedOk(bool in_opt_parsedOk)
2541	{
2542	JSON::ObjectBase::setBoolean("parsedOk"_s, in_opt_parsedOk);
2543	}
2544
2545	void setStatus(Protocol::CSS::CSSPropertyStatus in_opt_status)
2546	{
2547	JSON::ObjectBase::setString("status"_s, Protocol::Helpers::getEnumConstantValue(in_opt_status));
2548	}
2549
2550	void setRange(Ref<Protocol::CSS::SourceRange>&& in_opt_range)
2551	{
2552	JSON::ObjectBase::setObject("range"_s, WTFMove(in_opt_range));
2553	}
2554
2555	// Property names for type generated as open.
2556	JS_EXPORT_PRIVATE static const ASCIILiteral priorityKey;
2557	JS_EXPORT_PRIVATE static const ASCIILiteral parsedOkKey;
2558	JS_EXPORT_PRIVATE static const ASCIILiteral statusKey;
2559	};
2560
2561	/ CSS @media (as well as other users of media queries, like @import, <style>, <link>, etc.) and @supports descriptor. /
2562	class Grouping final : public JSON::ObjectBase {
2563	public:
2564	// Named after property name 'type' while generating Grouping.
2565	enum class Type {
2566	MediaRule = `37`,
2567	MediaImportRule = `38`,
2568	MediaLinkNode = `39`,
2569	MediaStyleNode = `40`,
2570	SupportsRule = `41`,
2571	}; // enum class Type
2572
2573	enum {
2574	NoFieldsSet = `0`,
2575	TextSet = `1` << `0`,
2576	TypeSet = `1` << `1`,
2577	AllFieldsSet = (TextSet \| TypeSet)
2578	};
2579
2580	template<int STATE>
2581	class Builder {
2582	private:
2583	RefPtr<JSON::Object> m_result;
2584
2585	template<int STEP> Builder<STATE \| STEP>& castState()
2586	{
2587	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
2588	}
2589
2590	Builder(Ref</Grouping/JSON::Object>&& object)
2591	: m_result (WTFMove(object))
2592	{
2593	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2594	}
2595	friend class Grouping;
2596	public:
2597
2598	Builder<STATE \| TextSet>& setText(const String& in_text)
2599	{
2600	COMPILE_ASSERT(!(STATE & TextSet), property_text_already_set);
2601	m_result ->setString("text"_s, in_text);
2602	return castState<TextSet>();
2603	}
2604
2605	Builder<STATE \| TypeSet>& setType(Type in_type)
2606	{
2607	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
2608	m_result ->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
2609	return castState<TypeSet>();
2610	}
2611
2612	Ref<Grouping> release()
2613	{
2614	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2615	COMPILE_ASSERT(sizeof(Grouping) == sizeof(JSON::Object), cannot_cast);
2616
2617	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2618	auto result = WTFMove(*reinterpret_cast<Ref<Grouping>*>(&jsonResult));
2619	return result;
2620	}
2621	};
2622
2623	/*
2624	* Synthetic constructor:
2625	* Ref<Grouping> result = Grouping::create()
2626	* .setText(...)
2627	* .setType(...)
2628	* .release();
2629	*/
2630	static Builder<NoFieldsSet> create()
2631	{
2632	return Builder<NoFieldsSet>(JSON::Object::create());
2633	}
2634
2635	void setSourceURL(const String& in_opt_sourceURL)
2636	{
2637	JSON::ObjectBase::setString("sourceURL"_s, in_opt_sourceURL);
2638	}
2639	};
2640
2641	/ A representation of WebCore::Font. Conceptually this is backed by either a font file on disk or from the network. /
2642	class Font final : public JSON::ObjectBase {
2643	public:
2644	enum {
2645	NoFieldsSet = `0`,
2646	DisplayNameSet = `1` << `0`,
2647	VariationAxesSet = `1` << `1`,
2648	AllFieldsSet = (DisplayNameSet \| VariationAxesSet)
2649	};
2650
2651	template<int STATE>
2652	class Builder {
2653	private:
2654	RefPtr<JSON::Object> m_result;
2655
2656	template<int STEP> Builder<STATE \| STEP>& castState()
2657	{
2658	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
2659	}
2660
2661	Builder(Ref</Font/JSON::Object>&& object)
2662	: m_result (WTFMove(object))
2663	{
2664	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2665	}
2666	friend class Font;
2667	public:
2668
2669	Builder<STATE \| DisplayNameSet>& setDisplayName(const String& in_displayName)
2670	{
2671	COMPILE_ASSERT(!(STATE & DisplayNameSet), property_displayName_already_set);
2672	m_result ->setString("displayName"_s, in_displayName);
2673	return castState<DisplayNameSet>();
2674	}
2675
2676	Builder<STATE \| VariationAxesSet>& setVariationAxes(Ref<JSON::ArrayOf<Protocol::CSS::FontVariationAxis>>&& in_variationAxes)
2677	{
2678	COMPILE_ASSERT(!(STATE & VariationAxesSet), property_variationAxes_already_set);
2679	m_result ->setArray("variationAxes"_s, WTFMove(in_variationAxes));
2680	return castState<VariationAxesSet>();
2681	}
2682
2683	Ref<Font> release()
2684	{
2685	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2686	COMPILE_ASSERT(sizeof(Font) == sizeof(JSON::Object), cannot_cast);
2687
2688	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2689	auto result = WTFMove(*reinterpret_cast<Ref<Font>*>(&jsonResult));
2690	return result;
2691	}
2692	};
2693
2694	/*
2695	* Synthetic constructor:
2696	* Ref<Font> result = Font::create()
2697	* .setDisplayName(...)
2698	* .setVariationAxes(...)
2699	* .release();
2700	*/
2701	static Builder<NoFieldsSet> create()
2702	{
2703	return Builder<NoFieldsSet>(JSON::Object::create());
2704	}
2705	};
2706
2707	/ A single variation axis associated with a Font. /
2708	class FontVariationAxis final : public JSON::ObjectBase {
2709	public:
2710	enum {
2711	NoFieldsSet = `0`,
2712	TagSet = `1` << `0`,
2713	MinimumValueSet = `1` << `1`,
2714	MaximumValueSet = `1` << `2`,
2715	DefaultValueSet = `1` << `3`,
2716	AllFieldsSet = (TagSet \| MinimumValueSet \| MaximumValueSet \| DefaultValueSet)
2717	};
2718
2719	template<int STATE>
2720	class Builder {
2721	private:
2722	RefPtr<JSON::Object> m_result;
2723
2724	template<int STEP> Builder<STATE \| STEP>& castState()
2725	{
2726	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
2727	}
2728
2729	Builder(Ref</FontVariationAxis/JSON::Object>&& object)
2730	: m_result (WTFMove(object))
2731	{
2732	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2733	}
2734	friend class FontVariationAxis;
2735	public:
2736
2737	Builder<STATE \| TagSet>& setTag(const String& in_tag)
2738	{
2739	COMPILE_ASSERT(!(STATE & TagSet), property_tag_already_set);
2740	m_result ->setString("tag"_s, in_tag);
2741	return castState<TagSet>();
2742	}
2743
2744	Builder<STATE \| MinimumValueSet>& setMinimumValue(double in_minimumValue)
2745	{
2746	COMPILE_ASSERT(!(STATE & MinimumValueSet), property_minimumValue_already_set);
2747	m_result ->setDouble("minimumValue"_s, in_minimumValue);
2748	return castState<MinimumValueSet>();
2749	}
2750
2751	Builder<STATE \| MaximumValueSet>& setMaximumValue(double in_maximumValue)
2752	{
2753	COMPILE_ASSERT(!(STATE & MaximumValueSet), property_maximumValue_already_set);
2754	m_result ->setDouble("maximumValue"_s, in_maximumValue);
2755	return castState<MaximumValueSet>();
2756	}
2757
2758	Builder<STATE \| DefaultValueSet>& setDefaultValue(double in_defaultValue)
2759	{
2760	COMPILE_ASSERT(!(STATE & DefaultValueSet), property_defaultValue_already_set);
2761	m_result ->setDouble("defaultValue"_s, in_defaultValue);
2762	return castState<DefaultValueSet>();
2763	}
2764
2765	Ref<FontVariationAxis> release()
2766	{
2767	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2768	COMPILE_ASSERT(sizeof(FontVariationAxis) == sizeof(JSON::Object), cannot_cast);
2769
2770	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2771	auto result = WTFMove(*reinterpret_cast<Ref<FontVariationAxis>*>(&jsonResult));
2772	return result;
2773	}
2774	};
2775
2776	/*
2777	* Synthetic constructor:
2778	* Ref<FontVariationAxis> result = FontVariationAxis::create()
2779	* .setTag(...)
2780	* .setMinimumValue(...)
2781	* .setMaximumValue(...)
2782	* .setDefaultValue(...)
2783	* .release();
2784	*/
2785	static Builder<NoFieldsSet> create()
2786	{
2787	return Builder<NoFieldsSet>(JSON::Object::create());
2788	}
2789
2790	void setName(const String& in_opt_name)
2791	{
2792	JSON::ObjectBase::setString("name"_s, in_opt_name);
2793	}
2794	};
2795
2796	/ The layout context type of a node. /
2797	enum class LayoutContextType {
2798	Grid = `42`,
2799	}; // enum class LayoutContextType
2800
2801	/* The mode for how layout context type changes are handled (default: <code>Observed</code>). <code>Observed</code> limits handling to those nodes already known to the frontend by other means (generally, this means the node is a visible item in the Elements tab). <code>All</code> informs the frontend of all layout context type changes and all nodes with a known layout context are sent to the frontend. */
2802	enum class LayoutContextTypeChangedMode {
2803	Observed = `43`,
2804	All = `44`,
2805	}; // enum class LayoutContextTypeChangedMode
2806
2807	} // CSS
2808
2809	namespace Canvas {
2810
2811	/ The type of rendering context backing the canvas element. /
2812	enum class ContextType {
2813	Canvas2D = `45`,
2814	BitmapRenderer = `46`,
2815	WebGL = `47`,
2816	WebGL2 = `48`,
2817	WebGPU = `49`,
2818	}; // enum class ContextType
2819
2820	#if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) \|\| (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
2821	enum class ProgramType {
2822	Compute = `50`,
2823	Render = `51`,
2824	}; // enum class ProgramType
2825	#endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) \|\| (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
2826
2827	#if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) \|\| (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
2828	enum class ShaderType {
2829	Compute = `50`,
2830	Fragment = `52`,
2831	Vertex = `53`,
2832	}; // enum class ShaderType
2833	#endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) \|\| (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
2834
2835	/ Drawing surface attributes. /
2836	class ContextAttributes final : public JSON::ObjectBase {
2837	public:
2838	enum {
2839	NoFieldsSet = `0`,
2840	AllFieldsSet = `0`
2841	};
2842
2843	template<int STATE>
2844	class Builder {
2845	private:
2846	RefPtr<JSON::Object> m_result;
2847
2848	template<int STEP> Builder<STATE \| STEP>& castState()
2849	{
2850	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
2851	}
2852
2853	Builder(Ref</ContextAttributes/JSON::Object>&& object)
2854	: m_result (WTFMove(object))
2855	{
2856	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2857	}
2858	friend class ContextAttributes;
2859	public:
2860
2861	Ref<ContextAttributes> release()
2862	{
2863	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2864	COMPILE_ASSERT(sizeof(ContextAttributes) == sizeof(JSON::Object), cannot_cast);
2865
2866	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2867	auto result = WTFMove(*reinterpret_cast<Ref<ContextAttributes>*>(&jsonResult));
2868	return result;
2869	}
2870	};
2871
2872	/*
2873	* Synthetic constructor:
2874	* Ref<ContextAttributes> result = ContextAttributes::create()
2875	* .release();
2876	*/
2877	static Builder<NoFieldsSet> create()
2878	{
2879	return Builder<NoFieldsSet>(JSON::Object::create());
2880	}
2881
2882	void setAlpha(bool in_opt_alpha)
2883	{
2884	JSON::ObjectBase::setBoolean("alpha"_s, in_opt_alpha);
2885	}
2886
2887	void setDepth(bool in_opt_depth)
2888	{
2889	JSON::ObjectBase::setBoolean("depth"_s, in_opt_depth);
2890	}
2891
2892	void setStencil(bool in_opt_stencil)
2893	{
2894	JSON::ObjectBase::setBoolean("stencil"_s, in_opt_stencil);
2895	}
2896
2897	void setAntialias(bool in_opt_antialias)
2898	{
2899	JSON::ObjectBase::setBoolean("antialias"_s, in_opt_antialias);
2900	}
2901
2902	void setPremultipliedAlpha(bool in_opt_premultipliedAlpha)
2903	{
2904	JSON::ObjectBase::setBoolean("premultipliedAlpha"_s, in_opt_premultipliedAlpha);
2905	}
2906
2907	void setPreserveDrawingBuffer(bool in_opt_preserveDrawingBuffer)
2908	{
2909	JSON::ObjectBase::setBoolean("preserveDrawingBuffer"_s, in_opt_preserveDrawingBuffer);
2910	}
2911
2912	void setFailIfMajorPerformanceCaveat(bool in_opt_failIfMajorPerformanceCaveat)
2913	{
2914	JSON::ObjectBase::setBoolean("failIfMajorPerformanceCaveat"_s, in_opt_failIfMajorPerformanceCaveat);
2915	}
2916
2917	void setPowerPreference(const String& in_opt_powerPreference)
2918	{
2919	JSON::ObjectBase::setString("powerPreference"_s, in_opt_powerPreference);
2920	}
2921	};
2922
2923	/ Information about a canvas for which a rendering context has been created. /
2924	class Canvas final : public JSON::ObjectBase {
2925	public:
2926	enum {
2927	NoFieldsSet = `0`,
2928	CanvasIdSet = `1` << `0`,
2929	ContextTypeSet = `1` << `1`,
2930	AllFieldsSet = (CanvasIdSet \| ContextTypeSet)
2931	};
2932
2933	template<int STATE>
2934	class Builder {
2935	private:
2936	RefPtr<JSON::Object> m_result;
2937
2938	template<int STEP> Builder<STATE \| STEP>& castState()
2939	{
2940	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
2941	}
2942
2943	Builder(Ref</Canvas/JSON::Object>&& object)
2944	: m_result (WTFMove(object))
2945	{
2946	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2947	}
2948	friend class Canvas;
2949	public:
2950
2951	Builder<STATE \| CanvasIdSet>& setCanvasId(const String& in_canvasId)
2952	{
2953	COMPILE_ASSERT(!(STATE & CanvasIdSet), property_canvasId_already_set);
2954	m_result ->setString("canvasId"_s, in_canvasId);
2955	return castState<CanvasIdSet>();
2956	}
2957
2958	Builder<STATE \| ContextTypeSet>& setContextType(Protocol::Canvas::ContextType in_contextType)
2959	{
2960	COMPILE_ASSERT(!(STATE & ContextTypeSet), property_contextType_already_set);
2961	m_result ->setString("contextType"_s, Protocol::Helpers::getEnumConstantValue(in_contextType));
2962	return castState<ContextTypeSet>();
2963	}
2964
2965	Ref<Canvas> release()
2966	{
2967	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2968	COMPILE_ASSERT(sizeof(Canvas) == sizeof(JSON::Object), cannot_cast);
2969
2970	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2971	auto result = WTFMove(*reinterpret_cast<Ref<Canvas>*>(&jsonResult));
2972	return result;
2973	}
2974	};
2975
2976	/*
2977	* Synthetic constructor:
2978	* Ref<Canvas> result = Canvas::create()
2979	* .setCanvasId(...)
2980	* .setContextType(...)
2981	* .release();
2982	*/
2983	static Builder<NoFieldsSet> create()
2984	{
2985	return Builder<NoFieldsSet>(JSON::Object::create());
2986	}
2987
2988	void setNodeId(int in_opt_nodeId)
2989	{
2990	JSON::ObjectBase::setInteger("nodeId"_s, in_opt_nodeId);
2991	}
2992
2993	void setCssCanvasName(const String& in_opt_cssCanvasName)
2994	{
2995	JSON::ObjectBase::setString("cssCanvasName"_s, in_opt_cssCanvasName);
2996	}
2997
2998	void setContextAttributes(Ref<Protocol::Canvas::ContextAttributes>&& in_opt_contextAttributes)
2999	{
3000	JSON::ObjectBase::setObject("contextAttributes"_s, WTFMove(in_opt_contextAttributes));
3001	}
3002
3003	void setMemoryCost(double in_opt_memoryCost)
3004	{
3005	JSON::ObjectBase::setDouble("memoryCost"_s, in_opt_memoryCost);
3006	}
3007
3008	void setBacktrace(Ref<JSON::ArrayOf<Protocol::Console::CallFrame>>&& in_opt_backtrace)
3009	{
3010	JSON::ObjectBase::setArray("backtrace"_s, WTFMove(in_opt_backtrace));
3011	}
3012	};
3013
3014	#if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) \|\| (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
3015	/ Information about a WebGL/WebGL2 shader program or WebGPU shader pipeline. /
3016	class ShaderProgram final : public JSON::ObjectBase {
3017	public:
3018	enum {
3019	NoFieldsSet = `0`,
3020	ProgramIdSet = `1` << `0`,
3021	ProgramTypeSet = `1` << `1`,
3022	CanvasIdSet = `1` << `2`,
3023	AllFieldsSet = (ProgramIdSet \| ProgramTypeSet \| CanvasIdSet)
3024	};
3025
3026	template<int STATE>
3027	class Builder {
3028	private:
3029	RefPtr<JSON::Object> m_result;
3030
3031	template<int STEP> Builder<STATE \| STEP>& castState()
3032	{
3033	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
3034	}
3035
3036	Builder(Ref</ShaderProgram/JSON::Object>&& object)
3037	: m_result (WTFMove(object))
3038	{
3039	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3040	}
3041	friend class ShaderProgram;
3042	public:
3043
3044	Builder<STATE \| ProgramIdSet>& setProgramId(const String& in_programId)
3045	{
3046	COMPILE_ASSERT(!(STATE & ProgramIdSet), property_programId_already_set);
3047	m_result ->setString("programId"_s, in_programId);
3048	return castState<ProgramIdSet>();
3049	}
3050
3051	Builder<STATE \| ProgramTypeSet>& setProgramType(Protocol::Canvas::ProgramType in_programType)
3052	{
3053	COMPILE_ASSERT(!(STATE & ProgramTypeSet), property_programType_already_set);
3054	m_result ->setString("programType"_s, Protocol::Helpers::getEnumConstantValue(in_programType));
3055	return castState<ProgramTypeSet>();
3056	}
3057
3058	Builder<STATE \| CanvasIdSet>& setCanvasId(const String& in_canvasId)
3059	{
3060	COMPILE_ASSERT(!(STATE & CanvasIdSet), property_canvasId_already_set);
3061	m_result ->setString("canvasId"_s, in_canvasId);
3062	return castState<CanvasIdSet>();
3063	}
3064
3065	Ref<ShaderProgram> release()
3066	{
3067	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3068	COMPILE_ASSERT(sizeof(ShaderProgram) == sizeof(JSON::Object), cannot_cast);
3069
3070	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3071	auto result = WTFMove(*reinterpret_cast<Ref<ShaderProgram>*>(&jsonResult));
3072	return result;
3073	}
3074	};
3075
3076	/*
3077	* Synthetic constructor:
3078	* Ref<ShaderProgram> result = ShaderProgram::create()
3079	* .setProgramId(...)
3080	* .setProgramType(...)
3081	* .setCanvasId(...)
3082	* .release();
3083	*/
3084	static Builder<NoFieldsSet> create()
3085	{
3086	return Builder<NoFieldsSet>(JSON::Object::create());
3087	}
3088
3089	void setSharesVertexFragmentShader(bool in_opt_sharesVertexFragmentShader)
3090	{
3091	JSON::ObjectBase::setBoolean("sharesVertexFragmentShader"_s, in_opt_sharesVertexFragmentShader);
3092	}
3093	};
3094	#endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) \|\| (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
3095
3096	} // Canvas
3097
3098	namespace Console {
3099
3100	/ Channels for different types of log messages. /
3101	enum class ChannelSource {
3102	XML = `54`,
3103	JavaScript = `55`,
3104	Network = `56`,
3105	ConsoleAPI = `57`,
3106	Storage = `58`,
3107	Appcache = `59`,
3108	Rendering = `60`,
3109	CSS = `61`,
3110	Security = `62`,
3111	ContentBlocker = `63`,
3112	Media = `64`,
3113	MediaSource = `65`,
3114	WebRTC = `66`,
3115	ITPDebug = `67`,
3116	PrivateClickMeasurement = `68`,
3117	PaymentRequest = `69`,
3118	Other = `70`,
3119	}; // enum class ChannelSource
3120
3121	/ Level of logging. /
3122	enum class ChannelLevel {
3123	Off = `71`,
3124	Basic = `72`,
3125	Verbose = `73`,
3126	}; // enum class ChannelLevel
3127
3128	/ Logging channel. /
3129	class Channel final : public JSON::ObjectBase {
3130	public:
3131	enum {
3132	NoFieldsSet = `0`,
3133	SourceSet = `1` << `0`,
3134	LevelSet = `1` << `1`,
3135	AllFieldsSet = (SourceSet \| LevelSet)
3136	};
3137
3138	template<int STATE>
3139	class Builder {
3140	private:
3141	RefPtr<JSON::Object> m_result;
3142
3143	template<int STEP> Builder<STATE \| STEP>& castState()
3144	{
3145	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
3146	}
3147
3148	Builder(Ref</Channel/JSON::Object>&& object)
3149	: m_result (WTFMove(object))
3150	{
3151	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3152	}
3153	friend class Channel;
3154	public:
3155
3156	Builder<STATE \| SourceSet>& setSource(Protocol::Console::ChannelSource in_source)
3157	{
3158	COMPILE_ASSERT(!(STATE & SourceSet), property_source_already_set);
3159	m_result ->setString("source"_s, Protocol::Helpers::getEnumConstantValue(in_source));
3160	return castState<SourceSet>();
3161	}
3162
3163	Builder<STATE \| LevelSet>& setLevel(Protocol::Console::ChannelLevel in_level)
3164	{
3165	COMPILE_ASSERT(!(STATE & LevelSet), property_level_already_set);
3166	m_result ->setString("level"_s, Protocol::Helpers::getEnumConstantValue(in_level));
3167	return castState<LevelSet>();
3168	}
3169
3170	Ref<Channel> release()
3171	{
3172	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3173	COMPILE_ASSERT(sizeof(Channel) == sizeof(JSON::Object), cannot_cast);
3174
3175	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3176	auto result = WTFMove(*reinterpret_cast<Ref<Channel>*>(&jsonResult));
3177	return result;
3178	}
3179	};
3180
3181	/*
3182	* Synthetic constructor:
3183	* Ref<Channel> result = Channel::create()
3184	* .setSource(...)
3185	* .setLevel(...)
3186	* .release();
3187	*/
3188	static Builder<NoFieldsSet> create()
3189	{
3190	return Builder<NoFieldsSet>(JSON::Object::create());
3191	}
3192	};
3193
3194	/ Console message. /
3195	class ConsoleMessage final : public JSON::ObjectBase {
3196	public:
3197	// Named after property name 'level' while generating ConsoleMessage.
3198	enum class Level {
3199	Log = `74`,
3200	Info = `75`,
3201	Warning = `76`,
3202	Error = `77`,
3203	Debug = `78`,
3204	}; // enum class Level
3205
3206	// Named after property name 'type' while generating ConsoleMessage.
3207	enum class Type {
3208	Log = `74`,
3209	Dir = `79`,
3210	DirXML = `80`,
3211	Table = `81`,
3212	Trace = `82`,
3213	Clear = `83`,
3214	StartGroup = `84`,
3215	StartGroupCollapsed = `85`,
3216	EndGroup = `86`,
3217	Assert = `87`,
3218	Timing = `88`,
3219	Profile = `89`,
3220	ProfileEnd = `90`,
3221	Image = `91`,
3222	}; // enum class Type
3223
3224	enum {
3225	NoFieldsSet = `0`,
3226	SourceSet = `1` << `0`,
3227	LevelSet = `1` << `1`,
3228	TextSet = `1` << `2`,
3229	AllFieldsSet = (SourceSet \| LevelSet \| TextSet)
3230	};
3231
3232	template<int STATE>
3233	class Builder {
3234	private:
3235	RefPtr<JSON::Object> m_result;
3236
3237	template<int STEP> Builder<STATE \| STEP>& castState()
3238	{
3239	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
3240	}
3241
3242	Builder(Ref</ConsoleMessage/JSON::Object>&& object)
3243	: m_result (WTFMove(object))
3244	{
3245	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3246	}
3247	friend class ConsoleMessage;
3248	public:
3249
3250	Builder<STATE \| SourceSet>& setSource(Protocol::Console::ChannelSource in_source)
3251	{
3252	COMPILE_ASSERT(!(STATE & SourceSet), property_source_already_set);
3253	m_result ->setString("source"_s, Protocol::Helpers::getEnumConstantValue(in_source));
3254	return castState<SourceSet>();
3255	}
3256
3257	Builder<STATE \| LevelSet>& setLevel(Level in_level)
3258	{
3259	COMPILE_ASSERT(!(STATE & LevelSet), property_level_already_set);
3260	m_result ->setString("level"_s, Protocol::Helpers::getEnumConstantValue(in_level));
3261	return castState<LevelSet>();
3262	}
3263
3264	Builder<STATE \| TextSet>& setText(const String& in_text)
3265	{
3266	COMPILE_ASSERT(!(STATE & TextSet), property_text_already_set);
3267	m_result ->setString("text"_s, in_text);
3268	return castState<TextSet>();
3269	}
3270
3271	Ref<ConsoleMessage> release()
3272	{
3273	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3274	COMPILE_ASSERT(sizeof(ConsoleMessage) == sizeof(JSON::Object), cannot_cast);
3275
3276	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3277	auto result = WTFMove(*reinterpret_cast<Ref<ConsoleMessage>*>(&jsonResult));
3278	return result;
3279	}
3280	};
3281
3282	/*
3283	* Synthetic constructor:
3284	* Ref<ConsoleMessage> result = ConsoleMessage::create()
3285	* .setSource(...)
3286	* .setLevel(...)
3287	* .setText(...)
3288	* .release();
3289	*/
3290	static Builder<NoFieldsSet> create()
3291	{
3292	return Builder<NoFieldsSet>(JSON::Object::create());
3293	}
3294
3295	void setType(Type in_opt_type)
3296	{
3297	JSON::ObjectBase::setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_opt_type));
3298	}
3299
3300	void setUrl(const String& in_opt_url)
3301	{
3302	JSON::ObjectBase::setString("url"_s, in_opt_url);
3303	}
3304
3305	void setLine(int in_opt_line)
3306	{
3307	JSON::ObjectBase::setInteger("line"_s, in_opt_line);
3308	}
3309
3310	void setColumn(int in_opt_column)
3311	{
3312	JSON::ObjectBase::setInteger("column"_s, in_opt_column);
3313	}
3314
3315	void setRepeatCount(int in_opt_repeatCount)
3316	{
3317	JSON::ObjectBase::setInteger("repeatCount"_s, in_opt_repeatCount);
3318	}
3319
3320	void setParameters(Ref<JSON::ArrayOf<Protocol::Runtime::RemoteObject>>&& in_opt_parameters)
3321	{
3322	JSON::ObjectBase::setArray("parameters"_s, WTFMove(in_opt_parameters));
3323	}
3324
3325	void setStackTrace(Ref<JSON::ArrayOf<Protocol::Console::CallFrame>>&& in_opt_stackTrace)
3326	{
3327	JSON::ObjectBase::setArray("stackTrace"_s, WTFMove(in_opt_stackTrace));
3328	}
3329
3330	void setNetworkRequestId(const String& in_opt_networkRequestId)
3331	{
3332	JSON::ObjectBase::setString("networkRequestId"_s, in_opt_networkRequestId);
3333	}
3334	};
3335
3336	/ Stack entry for console errors and assertions. /
3337	class CallFrame final : public JSON::ObjectBase {
3338	public:
3339	enum {
3340	NoFieldsSet = `0`,
3341	FunctionNameSet = `1` << `0`,
3342	UrlSet = `1` << `1`,
3343	ScriptIdSet = `1` << `2`,
3344	LineNumberSet = `1` << `3`,
3345	ColumnNumberSet = `1` << `4`,
3346	AllFieldsSet = (FunctionNameSet \| UrlSet \| ScriptIdSet \| LineNumberSet \| ColumnNumberSet)
3347	};
3348
3349	template<int STATE>
3350	class Builder {
3351	private:
3352	RefPtr<JSON::Object> m_result;
3353
3354	template<int STEP> Builder<STATE \| STEP>& castState()
3355	{
3356	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
3357	}
3358
3359	Builder(Ref</CallFrame/JSON::Object>&& object)
3360	: m_result (WTFMove(object))
3361	{
3362	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3363	}
3364	friend class CallFrame;
3365	public:
3366
3367	Builder<STATE \| FunctionNameSet>& setFunctionName(const String& in_functionName)
3368	{
3369	COMPILE_ASSERT(!(STATE & FunctionNameSet), property_functionName_already_set);
3370	m_result ->setString("functionName"_s, in_functionName);
3371	return castState<FunctionNameSet>();
3372	}
3373
3374	Builder<STATE \| UrlSet>& setUrl(const String& in_url)
3375	{
3376	COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
3377	m_result ->setString("url"_s, in_url);
3378	return castState<UrlSet>();
3379	}
3380
3381	Builder<STATE \| ScriptIdSet>& setScriptId(const String& in_scriptId)
3382	{
3383	COMPILE_ASSERT(!(STATE & ScriptIdSet), property_scriptId_already_set);
3384	m_result ->setString("scriptId"_s, in_scriptId);
3385	return castState<ScriptIdSet>();
3386	}
3387
3388	Builder<STATE \| LineNumberSet>& setLineNumber(int in_lineNumber)
3389	{
3390	COMPILE_ASSERT(!(STATE & LineNumberSet), property_lineNumber_already_set);
3391	m_result ->setInteger("lineNumber"_s, in_lineNumber);
3392	return castState<LineNumberSet>();
3393	}
3394
3395	Builder<STATE \| ColumnNumberSet>& setColumnNumber(int in_columnNumber)
3396	{
3397	COMPILE_ASSERT(!(STATE & ColumnNumberSet), property_columnNumber_already_set);
3398	m_result ->setInteger("columnNumber"_s, in_columnNumber);
3399	return castState<ColumnNumberSet>();
3400	}
3401
3402	Ref<CallFrame> release()
3403	{
3404	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3405	COMPILE_ASSERT(sizeof(CallFrame) == sizeof(JSON::Object), cannot_cast);
3406
3407	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3408	auto result = WTFMove(*reinterpret_cast<Ref<CallFrame>*>(&jsonResult));
3409	return result;
3410	}
3411	};
3412
3413	/*
3414	* Synthetic constructor:
3415	* Ref<CallFrame> result = CallFrame::create()
3416	* .setFunctionName(...)
3417	* .setUrl(...)
3418	* .setScriptId(...)
3419	* .setLineNumber(...)
3420	* .setColumnNumber(...)
3421	* .release();
3422	*/
3423	static Builder<NoFieldsSet> create()
3424	{
3425	return Builder<NoFieldsSet>(JSON::Object::create());
3426	}
3427	};
3428
3429	/ Call frames for async function calls, console assertions, and error messages. /
3430	class StackTrace final : public JSON::ObjectBase {
3431	public:
3432	enum {
3433	NoFieldsSet = `0`,
3434	CallFramesSet = `1` << `0`,
3435	AllFieldsSet = (CallFramesSet)
3436	};
3437
3438	template<int STATE>
3439	class Builder {
3440	private:
3441	RefPtr<JSON::Object> m_result;
3442
3443	template<int STEP> Builder<STATE \| STEP>& castState()
3444	{
3445	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
3446	}
3447
3448	Builder(Ref</StackTrace/JSON::Object>&& object)
3449	: m_result (WTFMove(object))
3450	{
3451	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3452	}
3453	friend class StackTrace;
3454	public:
3455
3456	Builder<STATE \| CallFramesSet>& setCallFrames(Ref<JSON::ArrayOf<Protocol::Console::CallFrame>>&& in_callFrames)
3457	{
3458	COMPILE_ASSERT(!(STATE & CallFramesSet), property_callFrames_already_set);
3459	m_result ->setArray("callFrames"_s, WTFMove(in_callFrames));
3460	return castState<CallFramesSet>();
3461	}
3462
3463	Ref<StackTrace> release()
3464	{
3465	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3466	COMPILE_ASSERT(sizeof(StackTrace) == sizeof(JSON::Object), cannot_cast);
3467
3468	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3469	auto result = WTFMove(*reinterpret_cast<Ref<StackTrace>*>(&jsonResult));
3470	return result;
3471	}
3472	};
3473
3474	/*
3475	* Synthetic constructor:
3476	* Ref<StackTrace> result = StackTrace::create()
3477	* .setCallFrames(...)
3478	* .release();
3479	*/
3480	static Builder<NoFieldsSet> create()
3481	{
3482	return Builder<NoFieldsSet>(JSON::Object::create());
3483	}
3484
3485	void setTopCallFrameIsBoundary(bool in_opt_topCallFrameIsBoundary)
3486	{
3487	JSON::ObjectBase::setBoolean("topCallFrameIsBoundary"_s, in_opt_topCallFrameIsBoundary);
3488	}
3489
3490	void setTruncated(bool in_opt_truncated)
3491	{
3492	JSON::ObjectBase::setBoolean("truncated"_s, in_opt_truncated);
3493	}
3494
3495	void setParentStackTrace(Ref<Protocol::Console::StackTrace>&& in_opt_parentStackTrace)
3496	{
3497	JSON::ObjectBase::setObject("parentStackTrace"_s, WTFMove(in_opt_parentStackTrace));
3498	}
3499	};
3500
3501	} // Console
3502
3503	namespace DOM {
3504
3505	/ Pseudo element type. /
3506	enum class PseudoType {
3507	Before = `24`,
3508	After = `25`,
3509	}; // enum class PseudoType
3510
3511	/ Shadow root type. /
3512	enum class ShadowRootType {
3513	UserAgent = `17`,
3514	Open = `92`,
3515	Closed = `93`,
3516	}; // enum class ShadowRootType
3517
3518	/ Custom element state. /
3519	enum class CustomElementState {
3520	Builtin = `94`,
3521	Custom = `95`,
3522	Waiting = `96`,
3523	Failed = `97`,
3524	}; // enum class CustomElementState
3525
3526	/ Token values of @aria-relevant attribute. /
3527	enum class LiveRegionRelevant {
3528	Additions = `98`,
3529	Removals = `99`,
3530	Text = `100`,
3531	}; // enum class LiveRegionRelevant
3532
3533	/ DOM interaction is implemented in terms of mirror objects that represent the actual DOM nodes. DOMNode is a base node mirror type. /
3534	class Node final : public JSON::ObjectBase {
3535	public:
3536	enum {
3537	NoFieldsSet = `0`,
3538	NodeIdSet = `1` << `0`,
3539	NodeTypeSet = `1` << `1`,
3540	NodeNameSet = `1` << `2`,
3541	LocalNameSet = `1` << `3`,
3542	NodeValueSet = `1` << `4`,
3543	AllFieldsSet = (NodeIdSet \| NodeTypeSet \| NodeNameSet \| LocalNameSet \| NodeValueSet)
3544	};
3545
3546	template<int STATE>
3547	class Builder {
3548	private:
3549	RefPtr<JSON::Object> m_result;
3550
3551	template<int STEP> Builder<STATE \| STEP>& castState()
3552	{
3553	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
3554	}
3555
3556	Builder(Ref</Node/JSON::Object>&& object)
3557	: m_result (WTFMove(object))
3558	{
3559	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3560	}
3561	friend class Node;
3562	public:
3563
3564	Builder<STATE \| NodeIdSet>& setNodeId(int in_nodeId)
3565	{
3566	COMPILE_ASSERT(!(STATE & NodeIdSet), property_nodeId_already_set);
3567	m_result ->setInteger("nodeId"_s, in_nodeId);
3568	return castState<NodeIdSet>();
3569	}
3570
3571	Builder<STATE \| NodeTypeSet>& setNodeType(int in_nodeType)
3572	{
3573	COMPILE_ASSERT(!(STATE & NodeTypeSet), property_nodeType_already_set);
3574	m_result ->setInteger("nodeType"_s, in_nodeType);
3575	return castState<NodeTypeSet>();
3576	}
3577
3578	Builder<STATE \| NodeNameSet>& setNodeName(const String& in_nodeName)
3579	{
3580	COMPILE_ASSERT(!(STATE & NodeNameSet), property_nodeName_already_set);
3581	m_result ->setString("nodeName"_s, in_nodeName);
3582	return castState<NodeNameSet>();
3583	}
3584
3585	Builder<STATE \| LocalNameSet>& setLocalName(const String& in_localName)
3586	{
3587	COMPILE_ASSERT(!(STATE & LocalNameSet), property_localName_already_set);
3588	m_result ->setString("localName"_s, in_localName);
3589	return castState<LocalNameSet>();
3590	}
3591
3592	Builder<STATE \| NodeValueSet>& setNodeValue(const String& in_nodeValue)
3593	{
3594	COMPILE_ASSERT(!(STATE & NodeValueSet), property_nodeValue_already_set);
3595	m_result ->setString("nodeValue"_s, in_nodeValue);
3596	return castState<NodeValueSet>();
3597	}
3598
3599	Ref<Node> release()
3600	{
3601	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3602	COMPILE_ASSERT(sizeof(Node) == sizeof(JSON::Object), cannot_cast);
3603
3604	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3605	auto result = WTFMove(*reinterpret_cast<Ref<Node>*>(&jsonResult));
3606	return result;
3607	}
3608	};
3609
3610	/*
3611	* Synthetic constructor:
3612	* Ref<Node> result = Node::create()
3613	* .setNodeId(...)
3614	* .setNodeType(...)
3615	* .setNodeName(...)
3616	* .setLocalName(...)
3617	* .setNodeValue(...)
3618	* .release();
3619	*/
3620	static Builder<NoFieldsSet> create()
3621	{
3622	return Builder<NoFieldsSet>(JSON::Object::create());
3623	}
3624
3625	void setFrameId(const String& in_opt_frameId)
3626	{
3627	JSON::ObjectBase::setString("frameId"_s, in_opt_frameId);
3628	}
3629
3630	void setChildNodeCount(int in_opt_childNodeCount)
3631	{
3632	JSON::ObjectBase::setInteger("childNodeCount"_s, in_opt_childNodeCount);
3633	}
3634
3635	void setChildren(Ref<JSON::ArrayOf<Protocol::DOM::Node>>&& in_opt_children)
3636	{
3637	JSON::ObjectBase::setArray("children"_s, WTFMove(in_opt_children));
3638	}
3639
3640	void setAttributes(Ref<JSON::ArrayOf<String>>&& in_opt_attributes)
3641	{
3642	JSON::ObjectBase::setArray("attributes"_s, WTFMove(in_opt_attributes));
3643	}
3644
3645	void setDocumentURL(const String& in_opt_documentURL)
3646	{
3647	JSON::ObjectBase::setString("documentURL"_s, in_opt_documentURL);
3648	}
3649
3650	void setBaseURL(const String& in_opt_baseURL)
3651	{
3652	JSON::ObjectBase::setString("baseURL"_s, in_opt_baseURL);
3653	}
3654
3655	void setPublicId(const String& in_opt_publicId)
3656	{
3657	JSON::ObjectBase::setString("publicId"_s, in_opt_publicId);
3658	}
3659
3660	void setSystemId(const String& in_opt_systemId)
3661	{
3662	JSON::ObjectBase::setString("systemId"_s, in_opt_systemId);
3663	}
3664
3665	void setXmlVersion(const String& in_opt_xmlVersion)
3666	{
3667	JSON::ObjectBase::setString("xmlVersion"_s, in_opt_xmlVersion);
3668	}
3669
3670	void setName(const String& in_opt_name)
3671	{
3672	JSON::ObjectBase::setString("name"_s, in_opt_name);
3673	}
3674
3675	void setValue(const String& in_opt_value)
3676	{
3677	JSON::ObjectBase::setString("value"_s, in_opt_value);
3678	}
3679
3680	void setPseudoType(Protocol::DOM::PseudoType in_opt_pseudoType)
3681	{
3682	JSON::ObjectBase::setString("pseudoType"_s, Protocol::Helpers::getEnumConstantValue(in_opt_pseudoType));
3683	}
3684
3685	void setShadowRootType(Protocol::DOM::ShadowRootType in_opt_shadowRootType)
3686	{
3687	JSON::ObjectBase::setString("shadowRootType"_s, Protocol::Helpers::getEnumConstantValue(in_opt_shadowRootType));
3688	}
3689
3690	void setCustomElementState(Protocol::DOM::CustomElementState in_opt_customElementState)
3691	{
3692	JSON::ObjectBase::setString("customElementState"_s, Protocol::Helpers::getEnumConstantValue(in_opt_customElementState));
3693	}
3694
3695	void setContentDocument(Ref<Protocol::DOM::Node>&& in_opt_contentDocument)
3696	{
3697	JSON::ObjectBase::setObject("contentDocument"_s, WTFMove(in_opt_contentDocument));
3698	}
3699
3700	void setShadowRoots(Ref<JSON::ArrayOf<Protocol::DOM::Node>>&& in_opt_shadowRoots)
3701	{
3702	JSON::ObjectBase::setArray("shadowRoots"_s, WTFMove(in_opt_shadowRoots));
3703	}
3704
3705	void setTemplateContent(Ref<Protocol::DOM::Node>&& in_opt_templateContent)
3706	{
3707	JSON::ObjectBase::setObject("templateContent"_s, WTFMove(in_opt_templateContent));
3708	}
3709
3710	void setPseudoElements(Ref<JSON::ArrayOf<Protocol::DOM::Node>>&& in_opt_pseudoElements)
3711	{
3712	JSON::ObjectBase::setArray("pseudoElements"_s, WTFMove(in_opt_pseudoElements));
3713	}
3714
3715	void setContentSecurityPolicyHash(const String& in_opt_contentSecurityPolicyHash)
3716	{
3717	JSON::ObjectBase::setString("contentSecurityPolicyHash"_s, in_opt_contentSecurityPolicyHash);
3718	}
3719
3720	void setLayoutContextType(Protocol::CSS::LayoutContextType in_opt_layoutContextType)
3721	{
3722	JSON::ObjectBase::setString("layoutContextType"_s, Protocol::Helpers::getEnumConstantValue(in_opt_layoutContextType));
3723	}
3724	};
3725
3726	/ Relationship between data that is associated with a node and the node itself. /
3727	class DataBinding final : public JSON::ObjectBase {
3728	public:
3729	enum {
3730	NoFieldsSet = `0`,
3731	BindingSet = `1` << `0`,
3732	ValueSet = `1` << `1`,
3733	AllFieldsSet = (BindingSet \| ValueSet)
3734	};
3735
3736	template<int STATE>
3737	class Builder {
3738	private:
3739	RefPtr<JSON::Object> m_result;
3740
3741	template<int STEP> Builder<STATE \| STEP>& castState()
3742	{
3743	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
3744	}
3745
3746	Builder(Ref</DataBinding/JSON::Object>&& object)
3747	: m_result (WTFMove(object))
3748	{
3749	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3750	}
3751	friend class DataBinding;
3752	public:
3753
3754	Builder<STATE \| BindingSet>& setBinding(const String& in_binding)
3755	{
3756	COMPILE_ASSERT(!(STATE & BindingSet), property_binding_already_set);
3757	m_result ->setString("binding"_s, in_binding);
3758	return castState<BindingSet>();
3759	}
3760
3761	Builder<STATE \| ValueSet>& setValue(const String& in_value)
3762	{
3763	COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set);
3764	m_result ->setString("value"_s, in_value);
3765	return castState<ValueSet>();
3766	}
3767
3768	Ref<DataBinding> release()
3769	{
3770	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3771	COMPILE_ASSERT(sizeof(DataBinding) == sizeof(JSON::Object), cannot_cast);
3772
3773	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3774	auto result = WTFMove(*reinterpret_cast<Ref<DataBinding>*>(&jsonResult));
3775	return result;
3776	}
3777	};
3778
3779	/*
3780	* Synthetic constructor:
3781	* Ref<DataBinding> result = DataBinding::create()
3782	* .setBinding(...)
3783	* .setValue(...)
3784	* .release();
3785	*/
3786	static Builder<NoFieldsSet> create()
3787	{
3788	return Builder<NoFieldsSet>(JSON::Object::create());
3789	}
3790
3791	void setType(const String& in_opt_type)
3792	{
3793	JSON::ObjectBase::setString("type"_s, in_opt_type);
3794	}
3795	};
3796
3797	/ A structure holding event listener properties. /
3798	class EventListener final : public JSON::ObjectBase {
3799	public:
3800	enum {
3801	NoFieldsSet = `0`,
3802	EventListenerIdSet = `1` << `0`,
3803	TypeSet = `1` << `1`,
3804	UseCaptureSet = `1` << `2`,
3805	IsAttributeSet = `1` << `3`,
3806	AllFieldsSet = (EventListenerIdSet \| TypeSet \| UseCaptureSet \| IsAttributeSet)
3807	};
3808
3809	template<int STATE>
3810	class Builder {
3811	private:
3812	RefPtr<JSON::Object> m_result;
3813
3814	template<int STEP> Builder<STATE \| STEP>& castState()
3815	{
3816	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
3817	}
3818
3819	Builder(Ref</EventListener/JSON::Object>&& object)
3820	: m_result (WTFMove(object))
3821	{
3822	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3823	}
3824	friend class EventListener;
3825	public:
3826
3827	Builder<STATE \| EventListenerIdSet>& setEventListenerId(int in_eventListenerId)
3828	{
3829	COMPILE_ASSERT(!(STATE & EventListenerIdSet), property_eventListenerId_already_set);
3830	m_result ->setInteger("eventListenerId"_s, in_eventListenerId);
3831	return castState<EventListenerIdSet>();
3832	}
3833
3834	Builder<STATE \| TypeSet>& setType(const String& in_type)
3835	{
3836	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
3837	m_result ->setString("type"_s, in_type);
3838	return castState<TypeSet>();
3839	}
3840
3841	Builder<STATE \| UseCaptureSet>& setUseCapture(bool in_useCapture)
3842	{
3843	COMPILE_ASSERT(!(STATE & UseCaptureSet), property_useCapture_already_set);
3844	m_result ->setBoolean("useCapture"_s, in_useCapture);
3845	return castState<UseCaptureSet>();
3846	}
3847
3848	Builder<STATE \| IsAttributeSet>& setIsAttribute(bool in_isAttribute)
3849	{
3850	COMPILE_ASSERT(!(STATE & IsAttributeSet), property_isAttribute_already_set);
3851	m_result ->setBoolean("isAttribute"_s, in_isAttribute);
3852	return castState<IsAttributeSet>();
3853	}
3854
3855	Ref<EventListener> release()
3856	{
3857	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3858	COMPILE_ASSERT(sizeof(EventListener) == sizeof(JSON::Object), cannot_cast);
3859
3860	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3861	auto result = WTFMove(*reinterpret_cast<Ref<EventListener>*>(&jsonResult));
3862	return result;
3863	}
3864	};
3865
3866	/*
3867	* Synthetic constructor:
3868	* Ref<EventListener> result = EventListener::create()
3869	* .setEventListenerId(...)
3870	* .setType(...)
3871	* .setUseCapture(...)
3872	* .setIsAttribute(...)
3873	* .release();
3874	*/
3875	static Builder<NoFieldsSet> create()
3876	{
3877	return Builder<NoFieldsSet>(JSON::Object::create());
3878	}
3879
3880	void setNodeId(int in_opt_nodeId)
3881	{
3882	JSON::ObjectBase::setInteger("nodeId"_s, in_opt_nodeId);
3883	}
3884
3885	void setOnWindow(bool in_opt_onWindow)
3886	{
3887	JSON::ObjectBase::setBoolean("onWindow"_s, in_opt_onWindow);
3888	}
3889
3890	void setLocation(Ref<Protocol::Debugger::Location>&& in_opt_location)
3891	{
3892	JSON::ObjectBase::setObject("location"_s, WTFMove(in_opt_location));
3893	}
3894
3895	void setHandlerName(const String& in_opt_handlerName)
3896	{
3897	JSON::ObjectBase::setString("handlerName"_s, in_opt_handlerName);
3898	}
3899
3900	void setPassive(bool in_opt_passive)
3901	{
3902	JSON::ObjectBase::setBoolean("passive"_s, in_opt_passive);
3903	}
3904
3905	void setOnce(bool in_opt_once)
3906	{
3907	JSON::ObjectBase::setBoolean("once"_s, in_opt_once);
3908	}
3909
3910	void setDisabled(bool in_opt_disabled)
3911	{
3912	JSON::ObjectBase::setBoolean("disabled"_s, in_opt_disabled);
3913	}
3914
3915	void setHasBreakpoint(bool in_opt_hasBreakpoint)
3916	{
3917	JSON::ObjectBase::setBoolean("hasBreakpoint"_s, in_opt_hasBreakpoint);
3918	}
3919	};
3920
3921	/ A structure holding accessibility properties. /
3922	class AccessibilityProperties final : public JSON::ObjectBase {
3923	public:
3924	// Named after property name 'checked' while generating AccessibilityProperties.
3925	enum class Checked {
3926	True = `101`,
3927	False = `102`,
3928	Mixed = `103`,
3929	}; // enum class Checked
3930
3931	// Named after property name 'current' while generating AccessibilityProperties.
3932	enum class Current {
3933	True = `101`,
3934	False = `102`,
3935	Page = `104`,
3936	Step = `105`,
3937	Location = `106`,
3938	Date = `107`,
3939	Time = `108`,
3940	}; // enum class Current
3941
3942	// Named after property name 'invalid' while generating AccessibilityProperties.
3943	enum class Invalid {
3944	True = `101`,
3945	False = `102`,
3946	Grammar = `109`,
3947	Spelling = `110`,
3948	}; // enum class Invalid
3949
3950	// Named after property name 'liveRegionStatus' while generating AccessibilityProperties.
3951	enum class LiveRegionStatus {
3952	Assertive = `111`,
3953	Polite = `112`,
3954	Off = `71`,
3955	}; // enum class LiveRegionStatus
3956
3957	enum {
3958	NoFieldsSet = `0`,
3959	ExistsSet = `1` << `0`,
3960	LabelSet = `1` << `1`,
3961	NodeIdSet = `1` << `2`,
3962	RoleSet = `1` << `3`,
3963	AllFieldsSet = (ExistsSet \| LabelSet \| NodeIdSet \| RoleSet)
3964	};
3965
3966	template<int STATE>
3967	class Builder {
3968	private:
3969	RefPtr<JSON::Object> m_result;
3970
3971	template<int STEP> Builder<STATE \| STEP>& castState()
3972	{
3973	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
3974	}
3975
3976	Builder(Ref</AccessibilityProperties/JSON::Object>&& object)
3977	: m_result (WTFMove(object))
3978	{
3979	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3980	}
3981	friend class AccessibilityProperties;
3982	public:
3983
3984	Builder<STATE \| ExistsSet>& setExists(bool in_exists)
3985	{
3986	COMPILE_ASSERT(!(STATE & ExistsSet), property_exists_already_set);
3987	m_result ->setBoolean("exists"_s, in_exists);
3988	return castState<ExistsSet>();
3989	}
3990
3991	Builder<STATE \| LabelSet>& setLabel(const String& in_label)
3992	{
3993	COMPILE_ASSERT(!(STATE & LabelSet), property_label_already_set);
3994	m_result ->setString("label"_s, in_label);
3995	return castState<LabelSet>();
3996	}
3997
3998	Builder<STATE \| NodeIdSet>& setNodeId(int in_nodeId)
3999	{
4000	COMPILE_ASSERT(!(STATE & NodeIdSet), property_nodeId_already_set);
4001	m_result ->setInteger("nodeId"_s, in_nodeId);
4002	return castState<NodeIdSet>();
4003	}
4004
4005	Builder<STATE \| RoleSet>& setRole(const String& in_role)
4006	{
4007	COMPILE_ASSERT(!(STATE & RoleSet), property_role_already_set);
4008	m_result ->setString("role"_s, in_role);
4009	return castState<RoleSet>();
4010	}
4011
4012	Ref<AccessibilityProperties> release()
4013	{
4014	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4015	COMPILE_ASSERT(sizeof(AccessibilityProperties) == sizeof(JSON::Object), cannot_cast);
4016
4017	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4018	auto result = WTFMove(*reinterpret_cast<Ref<AccessibilityProperties>*>(&jsonResult));
4019	return result;
4020	}
4021	};
4022
4023	/*
4024	* Synthetic constructor:
4025	* Ref<AccessibilityProperties> result = AccessibilityProperties::create()
4026	* .setExists(...)
4027	* .setLabel(...)
4028	* .setNodeId(...)
4029	* .setRole(...)
4030	* .release();
4031	*/
4032	static Builder<NoFieldsSet> create()
4033	{
4034	return Builder<NoFieldsSet>(JSON::Object::create());
4035	}
4036
4037	void setActiveDescendantNodeId(int in_opt_activeDescendantNodeId)
4038	{
4039	JSON::ObjectBase::setInteger("activeDescendantNodeId"_s, in_opt_activeDescendantNodeId);
4040	}
4041
4042	void setBusy(bool in_opt_busy)
4043	{
4044	JSON::ObjectBase::setBoolean("busy"_s, in_opt_busy);
4045	}
4046
4047	void setChecked(Checked in_opt_checked)
4048	{
4049	JSON::ObjectBase::setString("checked"_s, Protocol::Helpers::getEnumConstantValue(in_opt_checked));
4050	}
4051
4052	void setChildNodeIds(Ref<JSON::ArrayOf<int>>&& in_opt_childNodeIds)
4053	{
4054	JSON::ObjectBase::setArray("childNodeIds"_s, WTFMove(in_opt_childNodeIds));
4055	}
4056
4057	void setControlledNodeIds(Ref<JSON::ArrayOf<int>>&& in_opt_controlledNodeIds)
4058	{
4059	JSON::ObjectBase::setArray("controlledNodeIds"_s, WTFMove(in_opt_controlledNodeIds));
4060	}
4061
4062	void setCurrent(Current in_opt_current)
4063	{
4064	JSON::ObjectBase::setString("current"_s, Protocol::Helpers::getEnumConstantValue(in_opt_current));
4065	}
4066
4067	void setDisabled(bool in_opt_disabled)
4068	{
4069	JSON::ObjectBase::setBoolean("disabled"_s, in_opt_disabled);
4070	}
4071
4072	void setHeadingLevel(double in_opt_headingLevel)
4073	{
4074	JSON::ObjectBase::setDouble("headingLevel"_s, in_opt_headingLevel);
4075	}
4076
4077	void setHierarchyLevel(double in_opt_hierarchyLevel)
4078	{
4079	JSON::ObjectBase::setDouble("hierarchyLevel"_s, in_opt_hierarchyLevel);
4080	}
4081
4082	void setIsPopUpButton(bool in_opt_isPopUpButton)
4083	{
4084	JSON::ObjectBase::setBoolean("isPopUpButton"_s, in_opt_isPopUpButton);
4085	}
4086
4087	void setExpanded(bool in_opt_expanded)
4088	{
4089	JSON::ObjectBase::setBoolean("expanded"_s, in_opt_expanded);
4090	}
4091
4092	void setFlowedNodeIds(Ref<JSON::ArrayOf<int>>&& in_opt_flowedNodeIds)
4093	{
4094	JSON::ObjectBase::setArray("flowedNodeIds"_s, WTFMove(in_opt_flowedNodeIds));
4095	}
4096
4097	void setFocused(bool in_opt_focused)
4098	{
4099	JSON::ObjectBase::setBoolean("focused"_s, in_opt_focused);
4100	}
4101
4102	void setIgnored(bool in_opt_ignored)
4103	{
4104	JSON::ObjectBase::setBoolean("ignored"_s, in_opt_ignored);
4105	}
4106
4107	void setIgnoredByDefault(bool in_opt_ignoredByDefault)
4108	{
4109	JSON::ObjectBase::setBoolean("ignoredByDefault"_s, in_opt_ignoredByDefault);
4110	}
4111
4112	void setInvalid(Invalid in_opt_invalid)
4113	{
4114	JSON::ObjectBase::setString("invalid"_s, Protocol::Helpers::getEnumConstantValue(in_opt_invalid));
4115	}
4116
4117	void setHidden(bool in_opt_hidden)
4118	{
4119	JSON::ObjectBase::setBoolean("hidden"_s, in_opt_hidden);
4120	}
4121
4122	void setLiveRegionAtomic(bool in_opt_liveRegionAtomic)
4123	{
4124	JSON::ObjectBase::setBoolean("liveRegionAtomic"_s, in_opt_liveRegionAtomic);
4125	}
4126
4127	void setLiveRegionRelevant(Ref<JSON::ArrayOf<String>>&& in_opt_liveRegionRelevant)
4128	{
4129	JSON::ObjectBase::setArray("liveRegionRelevant"_s, WTFMove(in_opt_liveRegionRelevant));
4130	}
4131
4132	void setLiveRegionStatus(LiveRegionStatus in_opt_liveRegionStatus)
4133	{
4134	JSON::ObjectBase::setString("liveRegionStatus"_s, Protocol::Helpers::getEnumConstantValue(in_opt_liveRegionStatus));
4135	}
4136
4137	void setMouseEventNodeId(int in_opt_mouseEventNodeId)
4138	{
4139	JSON::ObjectBase::setInteger("mouseEventNodeId"_s, in_opt_mouseEventNodeId);
4140	}
4141
4142	void setOwnedNodeIds(Ref<JSON::ArrayOf<int>>&& in_opt_ownedNodeIds)
4143	{
4144	JSON::ObjectBase::setArray("ownedNodeIds"_s, WTFMove(in_opt_ownedNodeIds));
4145	}
4146
4147	void setParentNodeId(int in_opt_parentNodeId)
4148	{
4149	JSON::ObjectBase::setInteger("parentNodeId"_s, in_opt_parentNodeId);
4150	}
4151
4152	void setPressed(bool in_opt_pressed)
4153	{
4154	JSON::ObjectBase::setBoolean("pressed"_s, in_opt_pressed);
4155	}
4156
4157	void setReadonly(bool in_opt_readonly)
4158	{
4159	JSON::ObjectBase::setBoolean("readonly"_s, in_opt_readonly);
4160	}
4161
4162	void setRequired(bool in_opt_required)
4163	{
4164	JSON::ObjectBase::setBoolean("required"_s, in_opt_required);
4165	}
4166
4167	void setSelected(bool in_opt_selected)
4168	{
4169	JSON::ObjectBase::setBoolean("selected"_s, in_opt_selected);
4170	}
4171
4172	void setSelectedChildNodeIds(Ref<JSON::ArrayOf<int>>&& in_opt_selectedChildNodeIds)
4173	{
4174	JSON::ObjectBase::setArray("selectedChildNodeIds"_s, WTFMove(in_opt_selectedChildNodeIds));
4175	}
4176	};
4177
4178	/ A structure holding an RGBA color. /
4179	class RGBAColor final : public JSON::Object {
4180	public:
4181	enum {
4182	NoFieldsSet = `0`,
4183	RSet = `1` << `0`,
4184	GSet = `1` << `1`,
4185	BSet = `1` << `2`,
4186	AllFieldsSet = (RSet \| GSet \| BSet)
4187	};
4188
4189	template<int STATE>
4190	class Builder {
4191	private:
4192	RefPtr<JSON::Object> m_result;
4193
4194	template<int STEP> Builder<STATE \| STEP>& castState()
4195	{
4196	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
4197	}
4198
4199	Builder(Ref</RGBAColor/JSON::Object>&& object)
4200	: m_result (WTFMove(object))
4201	{
4202	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4203	}
4204	friend class RGBAColor;
4205	public:
4206
4207	Builder<STATE \| RSet>& setR(int in_r)
4208	{
4209	COMPILE_ASSERT(!(STATE & RSet), property_r_already_set);
4210	m_result ->setInteger("r"_s, in_r);
4211	return castState<RSet>();
4212	}
4213
4214	Builder<STATE \| GSet>& setG(int in_g)
4215	{
4216	COMPILE_ASSERT(!(STATE & GSet), property_g_already_set);
4217	m_result ->setInteger("g"_s, in_g);
4218	return castState<GSet>();
4219	}
4220
4221	Builder<STATE \| BSet>& setB(int in_b)
4222	{
4223	COMPILE_ASSERT(!(STATE & BSet), property_b_already_set);
4224	m_result ->setInteger("b"_s, in_b);
4225	return castState<BSet>();
4226	}
4227
4228	Ref<RGBAColor> release()
4229	{
4230	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4231	COMPILE_ASSERT(sizeof(RGBAColor) == sizeof(JSON::Object), cannot_cast);
4232
4233	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4234	auto result = WTFMove(*reinterpret_cast<Ref<RGBAColor>*>(&jsonResult));
4235	return result;
4236	}
4237	};
4238
4239	/*
4240	* Synthetic constructor:
4241	* Ref<RGBAColor> result = RGBAColor::create()
4242	* .setR(...)
4243	* .setG(...)
4244	* .setB(...)
4245	* .release();
4246	*/
4247	static Builder<NoFieldsSet> create()
4248	{
4249	return Builder<NoFieldsSet>(JSON::Object::create());
4250	}
4251
4252	void setA(double in_opt_a)
4253	{
4254	JSON::ObjectBase::setDouble("a"_s, in_opt_a);
4255	}
4256
4257	// Property names for type generated as open.
4258	JS_EXPORT_PRIVATE static const ASCIILiteral rKey;
4259	JS_EXPORT_PRIVATE static const ASCIILiteral gKey;
4260	JS_EXPORT_PRIVATE static const ASCIILiteral bKey;
4261	JS_EXPORT_PRIVATE static const ASCIILiteral aKey;
4262	};
4263
4264	/ Configuration data for the highlighting of page elements. /
4265	class HighlightConfig final : public JSON::Object {
4266	public:
4267	enum {
4268	NoFieldsSet = `0`,
4269	AllFieldsSet = `0`
4270	};
4271
4272	template<int STATE>
4273	class Builder {
4274	private:
4275	RefPtr<JSON::Object> m_result;
4276
4277	template<int STEP> Builder<STATE \| STEP>& castState()
4278	{
4279	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
4280	}
4281
4282	Builder(Ref</HighlightConfig/JSON::Object>&& object)
4283	: m_result (WTFMove(object))
4284	{
4285	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4286	}
4287	friend class HighlightConfig;
4288	public:
4289
4290	Ref<HighlightConfig> release()
4291	{
4292	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4293	COMPILE_ASSERT(sizeof(HighlightConfig) == sizeof(JSON::Object), cannot_cast);
4294
4295	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4296	auto result = WTFMove(*reinterpret_cast<Ref<HighlightConfig>*>(&jsonResult));
4297	return result;
4298	}
4299	};
4300
4301	/*
4302	* Synthetic constructor:
4303	* Ref<HighlightConfig> result = HighlightConfig::create()
4304	* .release();
4305	*/
4306	static Builder<NoFieldsSet> create()
4307	{
4308	return Builder<NoFieldsSet>(JSON::Object::create());
4309	}
4310
4311	void setShowInfo(bool in_opt_showInfo)
4312	{
4313	JSON::ObjectBase::setBoolean("showInfo"_s, in_opt_showInfo);
4314	}
4315
4316	void setContentColor(Ref<Protocol::DOM::RGBAColor>&& in_opt_contentColor)
4317	{
4318	JSON::ObjectBase::setObject("contentColor"_s, WTFMove(in_opt_contentColor));
4319	}
4320
4321	void setPaddingColor(Ref<Protocol::DOM::RGBAColor>&& in_opt_paddingColor)
4322	{
4323	JSON::ObjectBase::setObject("paddingColor"_s, WTFMove(in_opt_paddingColor));
4324	}
4325
4326	void setBorderColor(Ref<Protocol::DOM::RGBAColor>&& in_opt_borderColor)
4327	{
4328	JSON::ObjectBase::setObject("borderColor"_s, WTFMove(in_opt_borderColor));
4329	}
4330
4331	void setMarginColor(Ref<Protocol::DOM::RGBAColor>&& in_opt_marginColor)
4332	{
4333	JSON::ObjectBase::setObject("marginColor"_s, WTFMove(in_opt_marginColor));
4334	}
4335
4336	// Property names for type generated as open.
4337	JS_EXPORT_PRIVATE static const ASCIILiteral showInfoKey;
4338	JS_EXPORT_PRIVATE static const ASCIILiteral contentColorKey;
4339	JS_EXPORT_PRIVATE static const ASCIILiteral paddingColorKey;
4340	JS_EXPORT_PRIVATE static const ASCIILiteral borderColorKey;
4341	JS_EXPORT_PRIVATE static const ASCIILiteral marginColorKey;
4342	};
4343
4344	} // DOM
4345
4346	namespace DOMDebugger {
4347
4348	/ DOM breakpoint type. /
4349	enum class DOMBreakpointType {
4350	SubtreeModified = `113`,
4351	AttributeModified = `114`,
4352	NodeRemoved = `115`,
4353	}; // enum class DOMBreakpointType
4354
4355	/ Event breakpoint type. /
4356	enum class EventBreakpointType {
4357	AnimationFrame = `116`,
4358	Interval = `117`,
4359	Listener = `118`,
4360	Timeout = `119`,
4361	}; // enum class EventBreakpointType
4362
4363	} // DOMDebugger
4364
4365	namespace DOMStorage {
4366
4367	/ DOM Storage identifier. /
4368	class StorageId final : public JSON::Object {
4369	public:
4370	enum {
4371	NoFieldsSet = `0`,
4372	SecurityOriginSet = `1` << `0`,
4373	IsLocalStorageSet = `1` << `1`,
4374	AllFieldsSet = (SecurityOriginSet \| IsLocalStorageSet)
4375	};
4376
4377	template<int STATE>
4378	class Builder {
4379	private:
4380	RefPtr<JSON::Object> m_result;
4381
4382	template<int STEP> Builder<STATE \| STEP>& castState()
4383	{
4384	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
4385	}
4386
4387	Builder(Ref</StorageId/JSON::Object>&& object)
4388	: m_result (WTFMove(object))
4389	{
4390	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4391	}
4392	friend class StorageId;
4393	public:
4394
4395	Builder<STATE \| SecurityOriginSet>& setSecurityOrigin(const String& in_securityOrigin)
4396	{
4397	COMPILE_ASSERT(!(STATE & SecurityOriginSet), property_securityOrigin_already_set);
4398	m_result ->setString("securityOrigin"_s, in_securityOrigin);
4399	return castState<SecurityOriginSet>();
4400	}
4401
4402	Builder<STATE \| IsLocalStorageSet>& setIsLocalStorage(bool in_isLocalStorage)
4403	{
4404	COMPILE_ASSERT(!(STATE & IsLocalStorageSet), property_isLocalStorage_already_set);
4405	m_result ->setBoolean("isLocalStorage"_s, in_isLocalStorage);
4406	return castState<IsLocalStorageSet>();
4407	}
4408
4409	Ref<StorageId> release()
4410	{
4411	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4412	COMPILE_ASSERT(sizeof(StorageId) == sizeof(JSON::Object), cannot_cast);
4413
4414	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4415	auto result = WTFMove(*reinterpret_cast<Ref<StorageId>*>(&jsonResult));
4416	return result;
4417	}
4418	};
4419
4420	/*
4421	* Synthetic constructor:
4422	* Ref<StorageId> result = StorageId::create()
4423	* .setSecurityOrigin(...)
4424	* .setIsLocalStorage(...)
4425	* .release();
4426	*/
4427	static Builder<NoFieldsSet> create()
4428	{
4429	return Builder<NoFieldsSet>(JSON::Object::create());
4430	}
4431
4432	// Property names for type generated as open.
4433	JS_EXPORT_PRIVATE static const ASCIILiteral securityOriginKey;
4434	JS_EXPORT_PRIVATE static const ASCIILiteral isLocalStorageKey;
4435	};
4436
4437	} // DOMStorage
4438
4439	namespace Database {
4440
4441	/ Database object. /
4442	class Database final : public JSON::ObjectBase {
4443	public:
4444	enum {
4445	NoFieldsSet = `0`,
4446	IdSet = `1` << `0`,
4447	DomainSet = `1` << `1`,
4448	NameSet = `1` << `2`,
4449	VersionSet = `1` << `3`,
4450	AllFieldsSet = (IdSet \| DomainSet \| NameSet \| VersionSet)
4451	};
4452
4453	template<int STATE>
4454	class Builder {
4455	private:
4456	RefPtr<JSON::Object> m_result;
4457
4458	template<int STEP> Builder<STATE \| STEP>& castState()
4459	{
4460	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
4461	}
4462
4463	Builder(Ref</Database/JSON::Object>&& object)
4464	: m_result (WTFMove(object))
4465	{
4466	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4467	}
4468	friend class Database;
4469	public:
4470
4471	Builder<STATE \| IdSet>& setId(const String& in_id)
4472	{
4473	COMPILE_ASSERT(!(STATE & IdSet), property_id_already_set);
4474	m_result ->setString("id"_s, in_id);
4475	return castState<IdSet>();
4476	}
4477
4478	Builder<STATE \| DomainSet>& setDomain(const String& in_domain)
4479	{
4480	COMPILE_ASSERT(!(STATE & DomainSet), property_domain_already_set);
4481	m_result ->setString("domain"_s, in_domain);
4482	return castState<DomainSet>();
4483	}
4484
4485	Builder<STATE \| NameSet>& setName(const String& in_name)
4486	{
4487	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
4488	m_result ->setString("name"_s, in_name);
4489	return castState<NameSet>();
4490	}
4491
4492	Builder<STATE \| VersionSet>& setVersion(const String& in_version)
4493	{
4494	COMPILE_ASSERT(!(STATE & VersionSet), property_version_already_set);
4495	m_result ->setString("version"_s, in_version);
4496	return castState<VersionSet>();
4497	}
4498
4499	Ref<Database> release()
4500	{
4501	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4502	COMPILE_ASSERT(sizeof(Database) == sizeof(JSON::Object), cannot_cast);
4503
4504	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4505	auto result = WTFMove(*reinterpret_cast<Ref<Database>*>(&jsonResult));
4506	return result;
4507	}
4508	};
4509
4510	/*
4511	* Synthetic constructor:
4512	* Ref<Database> result = Database::create()
4513	* .setId(...)
4514	* .setDomain(...)
4515	* .setName(...)
4516	* .setVersion(...)
4517	* .release();
4518	*/
4519	static Builder<NoFieldsSet> create()
4520	{
4521	return Builder<NoFieldsSet>(JSON::Object::create());
4522	}
4523	};
4524
4525	/ Database error. /
4526	class Error final : public JSON::ObjectBase {
4527	public:
4528	enum {
4529	NoFieldsSet = `0`,
4530	MessageSet = `1` << `0`,
4531	CodeSet = `1` << `1`,
4532	AllFieldsSet = (MessageSet \| CodeSet)
4533	};
4534
4535	template<int STATE>
4536	class Builder {
4537	private:
4538	RefPtr<JSON::Object> m_result;
4539
4540	template<int STEP> Builder<STATE \| STEP>& castState()
4541	{
4542	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
4543	}
4544
4545	Builder(Ref</Error/JSON::Object>&& object)
4546	: m_result (WTFMove(object))
4547	{
4548	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4549	}
4550	friend class Error;
4551	public:
4552
4553	Builder<STATE \| MessageSet>& setMessage(const String& in_message)
4554	{
4555	COMPILE_ASSERT(!(STATE & MessageSet), property_message_already_set);
4556	m_result ->setString("message"_s, in_message);
4557	return castState<MessageSet>();
4558	}
4559
4560	Builder<STATE \| CodeSet>& setCode(int in_code)
4561	{
4562	COMPILE_ASSERT(!(STATE & CodeSet), property_code_already_set);
4563	m_result ->setInteger("code"_s, in_code);
4564	return castState<CodeSet>();
4565	}
4566
4567	Ref<Error> release()
4568	{
4569	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4570	COMPILE_ASSERT(sizeof(Error) == sizeof(JSON::Object), cannot_cast);
4571
4572	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4573	auto result = WTFMove(*reinterpret_cast<Ref<Error>*>(&jsonResult));
4574	return result;
4575	}
4576	};
4577
4578	/*
4579	* Synthetic constructor:
4580	* Ref<Error> result = Error::create()
4581	* .setMessage(...)
4582	* .setCode(...)
4583	* .release();
4584	*/
4585	static Builder<NoFieldsSet> create()
4586	{
4587	return Builder<NoFieldsSet>(JSON::Object::create());
4588	}
4589	};
4590
4591	} // Database
4592
4593	namespace Debugger {
4594
4595	/ Location in the source code. /
4596	class Location final : public JSON::Object {
4597	public:
4598	enum {
4599	NoFieldsSet = `0`,
4600	ScriptIdSet = `1` << `0`,
4601	LineNumberSet = `1` << `1`,
4602	AllFieldsSet = (ScriptIdSet \| LineNumberSet)
4603	};
4604
4605	template<int STATE>
4606	class Builder {
4607	private:
4608	RefPtr<JSON::Object> m_result;
4609
4610	template<int STEP> Builder<STATE \| STEP>& castState()
4611	{
4612	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
4613	}
4614
4615	Builder(Ref</Location/JSON::Object>&& object)
4616	: m_result (WTFMove(object))
4617	{
4618	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4619	}
4620	friend class Location;
4621	public:
4622
4623	Builder<STATE \| ScriptIdSet>& setScriptId(const String& in_scriptId)
4624	{
4625	COMPILE_ASSERT(!(STATE & ScriptIdSet), property_scriptId_already_set);
4626	m_result ->setString("scriptId"_s, in_scriptId);
4627	return castState<ScriptIdSet>();
4628	}
4629
4630	Builder<STATE \| LineNumberSet>& setLineNumber(int in_lineNumber)
4631	{
4632	COMPILE_ASSERT(!(STATE & LineNumberSet), property_lineNumber_already_set);
4633	m_result ->setInteger("lineNumber"_s, in_lineNumber);
4634	return castState<LineNumberSet>();
4635	}
4636
4637	Ref<Location> release()
4638	{
4639	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4640	COMPILE_ASSERT(sizeof(Location) == sizeof(JSON::Object), cannot_cast);
4641
4642	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4643	auto result = WTFMove(*reinterpret_cast<Ref<Location>*>(&jsonResult));
4644	return result;
4645	}
4646	};
4647
4648	/*
4649	* Synthetic constructor:
4650	* Ref<Location> result = Location::create()
4651	* .setScriptId(...)
4652	* .setLineNumber(...)
4653	* .release();
4654	*/
4655	static Builder<NoFieldsSet> create()
4656	{
4657	return Builder<NoFieldsSet>(JSON::Object::create());
4658	}
4659
4660	void setColumnNumber(int in_opt_columnNumber)
4661	{
4662	JSON::ObjectBase::setInteger("columnNumber"_s, in_opt_columnNumber);
4663	}
4664
4665	// Property names for type generated as open.
4666	JS_EXPORT_PRIVATE static const ASCIILiteral scriptIdKey;
4667	JS_EXPORT_PRIVATE static const ASCIILiteral lineNumberKey;
4668	JS_EXPORT_PRIVATE static const ASCIILiteral columnNumberKey;
4669	};
4670
4671	/ Action to perform when a breakpoint is triggered. /
4672	class BreakpointAction final : public JSON::Object {
4673	public:
4674	// Named after property name 'type' while generating BreakpointAction.
4675	enum class Type {
4676	Log = `74`,
4677	Evaluate = `120`,
4678	Sound = `121`,
4679	Probe = `122`,
4680	}; // enum class Type
4681
4682	enum {
4683	NoFieldsSet = `0`,
4684	TypeSet = `1` << `0`,
4685	AllFieldsSet = (TypeSet)
4686	};
4687
4688	template<int STATE>
4689	class Builder {
4690	private:
4691	RefPtr<JSON::Object> m_result;
4692
4693	template<int STEP> Builder<STATE \| STEP>& castState()
4694	{
4695	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
4696	}
4697
4698	Builder(Ref</BreakpointAction/JSON::Object>&& object)
4699	: m_result (WTFMove(object))
4700	{
4701	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4702	}
4703	friend class BreakpointAction;
4704	public:
4705
4706	Builder<STATE \| TypeSet>& setType(Type in_type)
4707	{
4708	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
4709	m_result ->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
4710	return castState<TypeSet>();
4711	}
4712
4713	Ref<BreakpointAction> release()
4714	{
4715	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4716	COMPILE_ASSERT(sizeof(BreakpointAction) == sizeof(JSON::Object), cannot_cast);
4717
4718	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4719	auto result = WTFMove(*reinterpret_cast<Ref<BreakpointAction>*>(&jsonResult));
4720	return result;
4721	}
4722	};
4723
4724	/*
4725	* Synthetic constructor:
4726	* Ref<BreakpointAction> result = BreakpointAction::create()
4727	* .setType(...)
4728	* .release();
4729	*/
4730	static Builder<NoFieldsSet> create()
4731	{
4732	return Builder<NoFieldsSet>(JSON::Object::create());
4733	}
4734
4735	void setData(const String& in_opt_data)
4736	{
4737	JSON::ObjectBase::setString("data"_s, in_opt_data);
4738	}
4739
4740	void setId(int in_opt_id)
4741	{
4742	JSON::ObjectBase::setInteger("id"_s, in_opt_id);
4743	}
4744
4745	void setEmulateUserGesture(bool in_opt_emulateUserGesture)
4746	{
4747	JSON::ObjectBase::setBoolean("emulateUserGesture"_s, in_opt_emulateUserGesture);
4748	}
4749
4750	// Property names for type generated as open.
4751	JS_EXPORT_PRIVATE static const ASCIILiteral typeKey;
4752	JS_EXPORT_PRIVATE static const ASCIILiteral dataKey;
4753	JS_EXPORT_PRIVATE static const ASCIILiteral idKey;
4754	JS_EXPORT_PRIVATE static const ASCIILiteral emulateUserGestureKey;
4755	};
4756
4757	/ Extra options that modify breakpoint behavior. /
4758	class BreakpointOptions final : public JSON::Object {
4759	public:
4760	enum {
4761	NoFieldsSet = `0`,
4762	AllFieldsSet = `0`
4763	};
4764
4765	template<int STATE>
4766	class Builder {
4767	private:
4768	RefPtr<JSON::Object> m_result;
4769
4770	template<int STEP> Builder<STATE \| STEP>& castState()
4771	{
4772	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
4773	}
4774
4775	Builder(Ref</BreakpointOptions/JSON::Object>&& object)
4776	: m_result (WTFMove(object))
4777	{
4778	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4779	}
4780	friend class BreakpointOptions;
4781	public:
4782
4783	Ref<BreakpointOptions> release()
4784	{
4785	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4786	COMPILE_ASSERT(sizeof(BreakpointOptions) == sizeof(JSON::Object), cannot_cast);
4787
4788	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4789	auto result = WTFMove(*reinterpret_cast<Ref<BreakpointOptions>*>(&jsonResult));
4790	return result;
4791	}
4792	};
4793
4794	/*
4795	* Synthetic constructor:
4796	* Ref<BreakpointOptions> result = BreakpointOptions::create()
4797	* .release();
4798	*/
4799	static Builder<NoFieldsSet> create()
4800	{
4801	return Builder<NoFieldsSet>(JSON::Object::create());
4802	}
4803
4804	void setCondition(const String& in_opt_condition)
4805	{
4806	JSON::ObjectBase::setString("condition"_s, in_opt_condition);
4807	}
4808
4809	void setActions(Ref<JSON::ArrayOf<Protocol::Debugger::BreakpointAction>>&& in_opt_actions)
4810	{
4811	JSON::ObjectBase::setArray("actions"_s, WTFMove(in_opt_actions));
4812	}
4813
4814	void setAutoContinue(bool in_opt_autoContinue)
4815	{
4816	JSON::ObjectBase::setBoolean("autoContinue"_s, in_opt_autoContinue);
4817	}
4818
4819	void setIgnoreCount(int in_opt_ignoreCount)
4820	{
4821	JSON::ObjectBase::setInteger("ignoreCount"_s, in_opt_ignoreCount);
4822	}
4823
4824	// Property names for type generated as open.
4825	JS_EXPORT_PRIVATE static const ASCIILiteral conditionKey;
4826	JS_EXPORT_PRIVATE static const ASCIILiteral actionsKey;
4827	JS_EXPORT_PRIVATE static const ASCIILiteral autoContinueKey;
4828	JS_EXPORT_PRIVATE static const ASCIILiteral ignoreCountKey;
4829	};
4830
4831	/ Information about the function. /
4832	class FunctionDetails final : public JSON::ObjectBase {
4833	public:
4834	enum {
4835	NoFieldsSet = `0`,
4836	LocationSet = `1` << `0`,
4837	AllFieldsSet = (LocationSet)
4838	};
4839
4840	template<int STATE>
4841	class Builder {
4842	private:
4843	RefPtr<JSON::Object> m_result;
4844
4845	template<int STEP> Builder<STATE \| STEP>& castState()
4846	{
4847	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
4848	}
4849
4850	Builder(Ref</FunctionDetails/JSON::Object>&& object)
4851	: m_result (WTFMove(object))
4852	{
4853	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4854	}
4855	friend class FunctionDetails;
4856	public:
4857
4858	Builder<STATE \| LocationSet>& setLocation(Ref<Protocol::Debugger::Location>&& in_location)
4859	{
4860	COMPILE_ASSERT(!(STATE & LocationSet), property_location_already_set);
4861	m_result ->setObject("location"_s, WTFMove(in_location));
4862	return castState<LocationSet>();
4863	}
4864
4865	Ref<FunctionDetails> release()
4866	{
4867	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4868	COMPILE_ASSERT(sizeof(FunctionDetails) == sizeof(JSON::Object), cannot_cast);
4869
4870	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4871	auto result = WTFMove(*reinterpret_cast<Ref<FunctionDetails>*>(&jsonResult));
4872	return result;
4873	}
4874	};
4875
4876	/*
4877	* Synthetic constructor:
4878	* Ref<FunctionDetails> result = FunctionDetails::create()
4879	* .setLocation(...)
4880	* .release();
4881	*/
4882	static Builder<NoFieldsSet> create()
4883	{
4884	return Builder<NoFieldsSet>(JSON::Object::create());
4885	}
4886
4887	void setName(const String& in_opt_name)
4888	{
4889	JSON::ObjectBase::setString("name"_s, in_opt_name);
4890	}
4891
4892	void setDisplayName(const String& in_opt_displayName)
4893	{
4894	JSON::ObjectBase::setString("displayName"_s, in_opt_displayName);
4895	}
4896
4897	void setScopeChain(Ref<JSON::ArrayOf<Protocol::Debugger::Scope>>&& in_opt_scopeChain)
4898	{
4899	JSON::ObjectBase::setArray("scopeChain"_s, WTFMove(in_opt_scopeChain));
4900	}
4901	};
4902
4903	/ JavaScript call frame. Array of call frames form the call stack. /
4904	class CallFrame final : public JSON::ObjectBase {
4905	public:
4906	enum {
4907	NoFieldsSet = `0`,
4908	CallFrameIdSet = `1` << `0`,
4909	FunctionNameSet = `1` << `1`,
4910	LocationSet = `1` << `2`,
4911	ScopeChainSet = `1` << `3`,
4912	ThisSet = `1` << `4`,
4913	IsTailDeletedSet = `1` << `5`,
4914	AllFieldsSet = (CallFrameIdSet \| FunctionNameSet \| LocationSet \| ScopeChainSet \| ThisSet \| IsTailDeletedSet)
4915	};
4916
4917	template<int STATE>
4918	class Builder {
4919	private:
4920	RefPtr<JSON::Object> m_result;
4921
4922	template<int STEP> Builder<STATE \| STEP>& castState()
4923	{
4924	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
4925	}
4926
4927	Builder(Ref</CallFrame/JSON::Object>&& object)
4928	: m_result (WTFMove(object))
4929	{
4930	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4931	}
4932	friend class CallFrame;
4933	public:
4934
4935	Builder<STATE \| CallFrameIdSet>& setCallFrameId(const String& in_callFrameId)
4936	{
4937	COMPILE_ASSERT(!(STATE & CallFrameIdSet), property_callFrameId_already_set);
4938	m_result ->setString("callFrameId"_s, in_callFrameId);
4939	return castState<CallFrameIdSet>();
4940	}
4941
4942	Builder<STATE \| FunctionNameSet>& setFunctionName(const String& in_functionName)
4943	{
4944	COMPILE_ASSERT(!(STATE & FunctionNameSet), property_functionName_already_set);
4945	m_result ->setString("functionName"_s, in_functionName);
4946	return castState<FunctionNameSet>();
4947	}
4948
4949	Builder<STATE \| LocationSet>& setLocation(Ref<Protocol::Debugger::Location>&& in_location)
4950	{
4951	COMPILE_ASSERT(!(STATE & LocationSet), property_location_already_set);
4952	m_result ->setObject("location"_s, WTFMove(in_location));
4953	return castState<LocationSet>();
4954	}
4955
4956	Builder<STATE \| ScopeChainSet>& setScopeChain(Ref<JSON::ArrayOf<Protocol::Debugger::Scope>>&& in_scopeChain)
4957	{
4958	COMPILE_ASSERT(!(STATE & ScopeChainSet), property_scopeChain_already_set);
4959	m_result ->setArray("scopeChain"_s, WTFMove(in_scopeChain));
4960	return castState<ScopeChainSet>();
4961	}
4962
4963	Builder<STATE \| ThisSet>& setThis(Ref<Protocol::Runtime::RemoteObject>&& in_this)
4964	{
4965	COMPILE_ASSERT(!(STATE & ThisSet), property_this_already_set);
4966	m_result ->setObject("this"_s, WTFMove(in_this));
4967	return castState<ThisSet>();
4968	}
4969
4970	Builder<STATE \| IsTailDeletedSet>& setIsTailDeleted(bool in_isTailDeleted)
4971	{
4972	COMPILE_ASSERT(!(STATE & IsTailDeletedSet), property_isTailDeleted_already_set);
4973	m_result ->setBoolean("isTailDeleted"_s, in_isTailDeleted);
4974	return castState<IsTailDeletedSet>();
4975	}
4976
4977	Ref<CallFrame> release()
4978	{
4979	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4980	COMPILE_ASSERT(sizeof(CallFrame) == sizeof(JSON::Object), cannot_cast);
4981
4982	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4983	auto result = WTFMove(*reinterpret_cast<Ref<CallFrame>*>(&jsonResult));
4984	return result;
4985	}
4986	};
4987
4988	/*
4989	* Synthetic constructor:
4990	* Ref<CallFrame> result = CallFrame::create()
4991	* .setCallFrameId(...)
4992	* .setFunctionName(...)
4993	* .setLocation(...)
4994	* .setScopeChain(...)
4995	* .setThis(...)
4996	* .setIsTailDeleted(...)
4997	* .release();
4998	*/
4999	static Builder<NoFieldsSet> create()
5000	{
5001	return Builder<NoFieldsSet>(JSON::Object::create());
5002	}
5003	};
5004
5005	/ Scope description. /
5006	class Scope final : public JSON::ObjectBase {
5007	public:
5008	// Named after property name 'type' while generating Scope.
5009	enum class Type {
5010	Global = `123`,
5011	With = `124`,
5012	Closure = `125`,
5013	Catch = `126`,
5014	FunctionName = `127`,
5015	GlobalLexicalEnvironment = `128`,
5016	NestedLexical = `129`,
5017	}; // enum class Type
5018
5019	enum {
5020	NoFieldsSet = `0`,
5021	ObjectSet = `1` << `0`,
5022	TypeSet = `1` << `1`,
5023	AllFieldsSet = (ObjectSet \| TypeSet)
5024	};
5025
5026	template<int STATE>
5027	class Builder {
5028	private:
5029	RefPtr<JSON::Object> m_result;
5030
5031	template<int STEP> Builder<STATE \| STEP>& castState()
5032	{
5033	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
5034	}
5035
5036	Builder(Ref</Scope/JSON::Object>&& object)
5037	: m_result (WTFMove(object))
5038	{
5039	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5040	}
5041	friend class Scope;
5042	public:
5043
5044	Builder<STATE \| ObjectSet>& setObject(Ref<Protocol::Runtime::RemoteObject>&& in_object)
5045	{
5046	COMPILE_ASSERT(!(STATE & ObjectSet), property_object_already_set);
5047	m_result ->setObject("object"_s, WTFMove(in_object));
5048	return castState<ObjectSet>();
5049	}
5050
5051	Builder<STATE \| TypeSet>& setType(Type in_type)
5052	{
5053	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
5054	m_result ->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
5055	return castState<TypeSet>();
5056	}
5057
5058	Ref<Scope> release()
5059	{
5060	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5061	COMPILE_ASSERT(sizeof(Scope) == sizeof(JSON::Object), cannot_cast);
5062
5063	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5064	auto result = WTFMove(*reinterpret_cast<Ref<Scope>*>(&jsonResult));
5065	return result;
5066	}
5067	};
5068
5069	/*
5070	* Synthetic constructor:
5071	* Ref<Scope> result = Scope::create()
5072	* .setObject(...)
5073	* .setType(...)
5074	* .release();
5075	*/
5076	static Builder<NoFieldsSet> create()
5077	{
5078	return Builder<NoFieldsSet>(JSON::Object::create());
5079	}
5080
5081	void setName(const String& in_opt_name)
5082	{
5083	JSON::ObjectBase::setString("name"_s, in_opt_name);
5084	}
5085
5086	void setLocation(Ref<Protocol::Debugger::Location>&& in_opt_location)
5087	{
5088	JSON::ObjectBase::setObject("location"_s, WTFMove(in_opt_location));
5089	}
5090
5091	void setEmpty(bool in_opt_empty)
5092	{
5093	JSON::ObjectBase::setBoolean("empty"_s, in_opt_empty);
5094	}
5095	};
5096
5097	/ A sample collected by evaluating a probe breakpoint action. /
5098	class ProbeSample final : public JSON::ObjectBase {
5099	public:
5100	enum {
5101	NoFieldsSet = `0`,
5102	ProbeIdSet = `1` << `0`,
5103	SampleIdSet = `1` << `1`,
5104	BatchIdSet = `1` << `2`,
5105	TimestampSet = `1` << `3`,
5106	PayloadSet = `1` << `4`,
5107	AllFieldsSet = (ProbeIdSet \| SampleIdSet \| BatchIdSet \| TimestampSet \| PayloadSet)
5108	};
5109
5110	template<int STATE>
5111	class Builder {
5112	private:
5113	RefPtr<JSON::Object> m_result;
5114
5115	template<int STEP> Builder<STATE \| STEP>& castState()
5116	{
5117	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
5118	}
5119
5120	Builder(Ref</ProbeSample/JSON::Object>&& object)
5121	: m_result (WTFMove(object))
5122	{
5123	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5124	}
5125	friend class ProbeSample;
5126	public:
5127
5128	Builder<STATE \| ProbeIdSet>& setProbeId(int in_probeId)
5129	{
5130	COMPILE_ASSERT(!(STATE & ProbeIdSet), property_probeId_already_set);
5131	m_result ->setInteger("probeId"_s, in_probeId);
5132	return castState<ProbeIdSet>();
5133	}
5134
5135	Builder<STATE \| SampleIdSet>& setSampleId(int in_sampleId)
5136	{
5137	COMPILE_ASSERT(!(STATE & SampleIdSet), property_sampleId_already_set);
5138	m_result ->setInteger("sampleId"_s, in_sampleId);
5139	return castState<SampleIdSet>();
5140	}
5141
5142	Builder<STATE \| BatchIdSet>& setBatchId(int in_batchId)
5143	{
5144	COMPILE_ASSERT(!(STATE & BatchIdSet), property_batchId_already_set);
5145	m_result ->setInteger("batchId"_s, in_batchId);
5146	return castState<BatchIdSet>();
5147	}
5148
5149	Builder<STATE \| TimestampSet>& setTimestamp(double in_timestamp)
5150	{
5151	COMPILE_ASSERT(!(STATE & TimestampSet), property_timestamp_already_set);
5152	m_result ->setDouble("timestamp"_s, in_timestamp);
5153	return castState<TimestampSet>();
5154	}
5155
5156	Builder<STATE \| PayloadSet>& setPayload(Ref<Protocol::Runtime::RemoteObject>&& in_payload)
5157	{
5158	COMPILE_ASSERT(!(STATE & PayloadSet), property_payload_already_set);
5159	m_result ->setObject("payload"_s, WTFMove(in_payload));
5160	return castState<PayloadSet>();
5161	}
5162
5163	Ref<ProbeSample> release()
5164	{
5165	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5166	COMPILE_ASSERT(sizeof(ProbeSample) == sizeof(JSON::Object), cannot_cast);
5167
5168	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5169	auto result = WTFMove(*reinterpret_cast<Ref<ProbeSample>*>(&jsonResult));
5170	return result;
5171	}
5172	};
5173
5174	/*
5175	* Synthetic constructor:
5176	* Ref<ProbeSample> result = ProbeSample::create()
5177	* .setProbeId(...)
5178	* .setSampleId(...)
5179	* .setBatchId(...)
5180	* .setTimestamp(...)
5181	* .setPayload(...)
5182	* .release();
5183	*/
5184	static Builder<NoFieldsSet> create()
5185	{
5186	return Builder<NoFieldsSet>(JSON::Object::create());
5187	}
5188	};
5189
5190	/ The pause reason auxiliary data when paused because of an assertion. /
5191	class AssertPauseReason final : public JSON::ObjectBase {
5192	public:
5193	enum {
5194	NoFieldsSet = `0`,
5195	AllFieldsSet = `0`
5196	};
5197
5198	template<int STATE>
5199	class Builder {
5200	private:
5201	RefPtr<JSON::Object> m_result;
5202
5203	template<int STEP> Builder<STATE \| STEP>& castState()
5204	{
5205	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
5206	}
5207
5208	Builder(Ref</AssertPauseReason/JSON::Object>&& object)
5209	: m_result (WTFMove(object))
5210	{
5211	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5212	}
5213	friend class AssertPauseReason;
5214	public:
5215
5216	Ref<AssertPauseReason> release()
5217	{
5218	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5219	COMPILE_ASSERT(sizeof(AssertPauseReason) == sizeof(JSON::Object), cannot_cast);
5220
5221	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5222	auto result = WTFMove(*reinterpret_cast<Ref<AssertPauseReason>*>(&jsonResult));
5223	return result;
5224	}
5225	};
5226
5227	/*
5228	* Synthetic constructor:
5229	* Ref<AssertPauseReason> result = AssertPauseReason::create()
5230	* .release();
5231	*/
5232	static Builder<NoFieldsSet> create()
5233	{
5234	return Builder<NoFieldsSet>(JSON::Object::create());
5235	}
5236
5237	void setMessage(const String& in_opt_message)
5238	{
5239	JSON::ObjectBase::setString("message"_s, in_opt_message);
5240	}
5241	};
5242
5243	/ The pause reason auxiliary data when paused because of hitting a breakpoint. /
5244	class BreakpointPauseReason final : public JSON::ObjectBase {
5245	public:
5246	enum {
5247	NoFieldsSet = `0`,
5248	BreakpointIdSet = `1` << `0`,
5249	AllFieldsSet = (BreakpointIdSet)
5250	};
5251
5252	template<int STATE>
5253	class Builder {
5254	private:
5255	RefPtr<JSON::Object> m_result;
5256
5257	template<int STEP> Builder<STATE \| STEP>& castState()
5258	{
5259	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
5260	}
5261
5262	Builder(Ref</BreakpointPauseReason/JSON::Object>&& object)
5263	: m_result (WTFMove(object))
5264	{
5265	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5266	}
5267	friend class BreakpointPauseReason;
5268	public:
5269
5270	Builder<STATE \| BreakpointIdSet>& setBreakpointId(const String& in_breakpointId)
5271	{
5272	COMPILE_ASSERT(!(STATE & BreakpointIdSet), property_breakpointId_already_set);
5273	m_result ->setString("breakpointId"_s, in_breakpointId);
5274	return castState<BreakpointIdSet>();
5275	}
5276
5277	Ref<BreakpointPauseReason> release()
5278	{
5279	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5280	COMPILE_ASSERT(sizeof(BreakpointPauseReason) == sizeof(JSON::Object), cannot_cast);
5281
5282	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5283	auto result = WTFMove(*reinterpret_cast<Ref<BreakpointPauseReason>*>(&jsonResult));
5284	return result;
5285	}
5286	};
5287
5288	/*
5289	* Synthetic constructor:
5290	* Ref<BreakpointPauseReason> result = BreakpointPauseReason::create()
5291	* .setBreakpointId(...)
5292	* .release();
5293	*/
5294	static Builder<NoFieldsSet> create()
5295	{
5296	return Builder<NoFieldsSet>(JSON::Object::create());
5297	}
5298	};
5299
5300	/ The pause reason auxiliary data when paused because of a Content Security Policy directive. /
5301	class CSPViolationPauseReason final : public JSON::ObjectBase {
5302	public:
5303	enum {
5304	NoFieldsSet = `0`,
5305	DirectiveSet = `1` << `0`,
5306	AllFieldsSet = (DirectiveSet)
5307	};
5308
5309	template<int STATE>
5310	class Builder {
5311	private:
5312	RefPtr<JSON::Object> m_result;
5313
5314	template<int STEP> Builder<STATE \| STEP>& castState()
5315	{
5316	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
5317	}
5318
5319	Builder(Ref</CSPViolationPauseReason/JSON::Object>&& object)
5320	: m_result (WTFMove(object))
5321	{
5322	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5323	}
5324	friend class CSPViolationPauseReason;
5325	public:
5326
5327	Builder<STATE \| DirectiveSet>& setDirective(const String& in_directive)
5328	{
5329	COMPILE_ASSERT(!(STATE & DirectiveSet), property_directive_already_set);
5330	m_result ->setString("directive"_s, in_directive);
5331	return castState<DirectiveSet>();
5332	}
5333
5334	Ref<CSPViolationPauseReason> release()
5335	{
5336	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5337	COMPILE_ASSERT(sizeof(CSPViolationPauseReason) == sizeof(JSON::Object), cannot_cast);
5338
5339	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5340	auto result = WTFMove(*reinterpret_cast<Ref<CSPViolationPauseReason>*>(&jsonResult));
5341	return result;
5342	}
5343	};
5344
5345	/*
5346	* Synthetic constructor:
5347	* Ref<CSPViolationPauseReason> result = CSPViolationPauseReason::create()
5348	* .setDirective(...)
5349	* .release();
5350	*/
5351	static Builder<NoFieldsSet> create()
5352	{
5353	return Builder<NoFieldsSet>(JSON::Object::create());
5354	}
5355	};
5356
5357	} // Debugger
5358
5359	namespace GenericTypes {
5360
5361	/ Search match in a resource. /
5362	class SearchMatch final : public JSON::ObjectBase {
5363	public:
5364	enum {
5365	NoFieldsSet = `0`,
5366	LineNumberSet = `1` << `0`,
5367	LineContentSet = `1` << `1`,
5368	AllFieldsSet = (LineNumberSet \| LineContentSet)
5369	};
5370
5371	template<int STATE>
5372	class Builder {
5373	private:
5374	RefPtr<JSON::Object> m_result;
5375
5376	template<int STEP> Builder<STATE \| STEP>& castState()
5377	{
5378	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
5379	}
5380
5381	Builder(Ref</SearchMatch/JSON::Object>&& object)
5382	: m_result (WTFMove(object))
5383	{
5384	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5385	}
5386	friend class SearchMatch;
5387	public:
5388
5389	Builder<STATE \| LineNumberSet>& setLineNumber(double in_lineNumber)
5390	{
5391	COMPILE_ASSERT(!(STATE & LineNumberSet), property_lineNumber_already_set);
5392	m_result ->setDouble("lineNumber"_s, in_lineNumber);
5393	return castState<LineNumberSet>();
5394	}
5395
5396	Builder<STATE \| LineContentSet>& setLineContent(const String& in_lineContent)
5397	{
5398	COMPILE_ASSERT(!(STATE & LineContentSet), property_lineContent_already_set);
5399	m_result ->setString("lineContent"_s, in_lineContent);
5400	return castState<LineContentSet>();
5401	}
5402
5403	Ref<SearchMatch> release()
5404	{
5405	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5406	COMPILE_ASSERT(sizeof(SearchMatch) == sizeof(JSON::Object), cannot_cast);
5407
5408	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5409	auto result = WTFMove(*reinterpret_cast<Ref<SearchMatch>*>(&jsonResult));
5410	return result;
5411	}
5412	};
5413
5414	/*
5415	* Synthetic constructor:
5416	* Ref<SearchMatch> result = SearchMatch::create()
5417	* .setLineNumber(...)
5418	* .setLineContent(...)
5419	* .release();
5420	*/
5421	static Builder<NoFieldsSet> create()
5422	{
5423	return Builder<NoFieldsSet>(JSON::Object::create());
5424	}
5425	};
5426
5427	} // GenericTypes
5428
5429	namespace Heap {
5430
5431	/ Information about a garbage collection. /
5432	class GarbageCollection final : public JSON::ObjectBase {
5433	public:
5434	// Named after property name 'type' while generating GarbageCollection.
5435	enum class Type {
5436	Full = `130`,
5437	Partial = `131`,
5438	}; // enum class Type
5439
5440	enum {
5441	NoFieldsSet = `0`,
5442	TypeSet = `1` << `0`,
5443	StartTimeSet = `1` << `1`,
5444	EndTimeSet = `1` << `2`,
5445	AllFieldsSet = (TypeSet \| StartTimeSet \| EndTimeSet)
5446	};
5447
5448	template<int STATE>
5449	class Builder {
5450	private:
5451	RefPtr<JSON::Object> m_result;
5452
5453	template<int STEP> Builder<STATE \| STEP>& castState()
5454	{
5455	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
5456	}
5457
5458	Builder(Ref</GarbageCollection/JSON::Object>&& object)
5459	: m_result (WTFMove(object))
5460	{
5461	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5462	}
5463	friend class GarbageCollection;
5464	public:
5465
5466	Builder<STATE \| TypeSet>& setType(Type in_type)
5467	{
5468	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
5469	m_result ->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
5470	return castState<TypeSet>();
5471	}
5472
5473	Builder<STATE \| StartTimeSet>& setStartTime(double in_startTime)
5474	{
5475	COMPILE_ASSERT(!(STATE & StartTimeSet), property_startTime_already_set);
5476	m_result ->setDouble("startTime"_s, in_startTime);
5477	return castState<StartTimeSet>();
5478	}
5479
5480	Builder<STATE \| EndTimeSet>& setEndTime(double in_endTime)
5481	{
5482	COMPILE_ASSERT(!(STATE & EndTimeSet), property_endTime_already_set);
5483	m_result ->setDouble("endTime"_s, in_endTime);
5484	return castState<EndTimeSet>();
5485	}
5486
5487	Ref<GarbageCollection> release()
5488	{
5489	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5490	COMPILE_ASSERT(sizeof(GarbageCollection) == sizeof(JSON::Object), cannot_cast);
5491
5492	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5493	auto result = WTFMove(*reinterpret_cast<Ref<GarbageCollection>*>(&jsonResult));
5494	return result;
5495	}
5496	};
5497
5498	/*
5499	* Synthetic constructor:
5500	* Ref<GarbageCollection> result = GarbageCollection::create()
5501	* .setType(...)
5502	* .setStartTime(...)
5503	* .setEndTime(...)
5504	* .release();
5505	*/
5506	static Builder<NoFieldsSet> create()
5507	{
5508	return Builder<NoFieldsSet>(JSON::Object::create());
5509	}
5510	};
5511
5512	} // Heap
5513
5514	namespace IndexedDB {
5515
5516	/ Database with an array of object stores. /
5517	class DatabaseWithObjectStores final : public JSON::ObjectBase {
5518	public:
5519	enum {
5520	NoFieldsSet = `0`,
5521	NameSet = `1` << `0`,
5522	VersionSet = `1` << `1`,
5523	ObjectStoresSet = `1` << `2`,
5524	AllFieldsSet = (NameSet \| VersionSet \| ObjectStoresSet)
5525	};
5526
5527	template<int STATE>
5528	class Builder {
5529	private:
5530	RefPtr<JSON::Object> m_result;
5531
5532	template<int STEP> Builder<STATE \| STEP>& castState()
5533	{
5534	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
5535	}
5536
5537	Builder(Ref</DatabaseWithObjectStores/JSON::Object>&& object)
5538	: m_result (WTFMove(object))
5539	{
5540	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5541	}
5542	friend class DatabaseWithObjectStores;
5543	public:
5544
5545	Builder<STATE \| NameSet>& setName(const String& in_name)
5546	{
5547	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
5548	m_result ->setString("name"_s, in_name);
5549	return castState<NameSet>();
5550	}
5551
5552	Builder<STATE \| VersionSet>& setVersion(double in_version)
5553	{
5554	COMPILE_ASSERT(!(STATE & VersionSet), property_version_already_set);
5555	m_result ->setDouble("version"_s, in_version);
5556	return castState<VersionSet>();
5557	}
5558
5559	Builder<STATE \| ObjectStoresSet>& setObjectStores(Ref<JSON::ArrayOf<Protocol::IndexedDB::ObjectStore>>&& in_objectStores)
5560	{
5561	COMPILE_ASSERT(!(STATE & ObjectStoresSet), property_objectStores_already_set);
5562	m_result ->setArray("objectStores"_s, WTFMove(in_objectStores));
5563	return castState<ObjectStoresSet>();
5564	}
5565
5566	Ref<DatabaseWithObjectStores> release()
5567	{
5568	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5569	COMPILE_ASSERT(sizeof(DatabaseWithObjectStores) == sizeof(JSON::Object), cannot_cast);
5570
5571	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5572	auto result = WTFMove(*reinterpret_cast<Ref<DatabaseWithObjectStores>*>(&jsonResult));
5573	return result;
5574	}
5575	};
5576
5577	/*
5578	* Synthetic constructor:
5579	* Ref<DatabaseWithObjectStores> result = DatabaseWithObjectStores::create()
5580	* .setName(...)
5581	* .setVersion(...)
5582	* .setObjectStores(...)
5583	* .release();
5584	*/
5585	static Builder<NoFieldsSet> create()
5586	{
5587	return Builder<NoFieldsSet>(JSON::Object::create());
5588	}
5589	};
5590
5591	/ Object store. /
5592	class ObjectStore final : public JSON::ObjectBase {
5593	public:
5594	enum {
5595	NoFieldsSet = `0`,
5596	NameSet = `1` << `0`,
5597	KeyPathSet = `1` << `1`,
5598	AutoIncrementSet = `1` << `2`,
5599	IndexesSet = `1` << `3`,
5600	AllFieldsSet = (NameSet \| KeyPathSet \| AutoIncrementSet \| IndexesSet)
5601	};
5602
5603	template<int STATE>
5604	class Builder {
5605	private:
5606	RefPtr<JSON::Object> m_result;
5607
5608	template<int STEP> Builder<STATE \| STEP>& castState()
5609	{
5610	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
5611	}
5612
5613	Builder(Ref</ObjectStore/JSON::Object>&& object)
5614	: m_result (WTFMove(object))
5615	{
5616	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5617	}
5618	friend class ObjectStore;
5619	public:
5620
5621	Builder<STATE \| NameSet>& setName(const String& in_name)
5622	{
5623	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
5624	m_result ->setString("name"_s, in_name);
5625	return castState<NameSet>();
5626	}
5627
5628	Builder<STATE \| KeyPathSet>& setKeyPath(Ref<Protocol::IndexedDB::KeyPath>&& in_keyPath)
5629	{
5630	COMPILE_ASSERT(!(STATE & KeyPathSet), property_keyPath_already_set);
5631	m_result ->setObject("keyPath"_s, WTFMove(in_keyPath));
5632	return castState<KeyPathSet>();
5633	}
5634
5635	Builder<STATE \| AutoIncrementSet>& setAutoIncrement(bool in_autoIncrement)
5636	{
5637	COMPILE_ASSERT(!(STATE & AutoIncrementSet), property_autoIncrement_already_set);
5638	m_result ->setBoolean("autoIncrement"_s, in_autoIncrement);
5639	return castState<AutoIncrementSet>();
5640	}
5641
5642	Builder<STATE \| IndexesSet>& setIndexes(Ref<JSON::ArrayOf<Protocol::IndexedDB::ObjectStoreIndex>>&& in_indexes)
5643	{
5644	COMPILE_ASSERT(!(STATE & IndexesSet), property_indexes_already_set);
5645	m_result ->setArray("indexes"_s, WTFMove(in_indexes));
5646	return castState<IndexesSet>();
5647	}
5648
5649	Ref<ObjectStore> release()
5650	{
5651	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5652	COMPILE_ASSERT(sizeof(ObjectStore) == sizeof(JSON::Object), cannot_cast);
5653
5654	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5655	auto result = WTFMove(*reinterpret_cast<Ref<ObjectStore>*>(&jsonResult));
5656	return result;
5657	}
5658	};
5659
5660	/*
5661	* Synthetic constructor:
5662	* Ref<ObjectStore> result = ObjectStore::create()
5663	* .setName(...)
5664	* .setKeyPath(...)
5665	* .setAutoIncrement(...)
5666	* .setIndexes(...)
5667	* .release();
5668	*/
5669	static Builder<NoFieldsSet> create()
5670	{
5671	return Builder<NoFieldsSet>(JSON::Object::create());
5672	}
5673	};
5674
5675	/ Object store index. /
5676	class ObjectStoreIndex final : public JSON::ObjectBase {
5677	public:
5678	enum {
5679	NoFieldsSet = `0`,
5680	NameSet = `1` << `0`,
5681	KeyPathSet = `1` << `1`,
5682	UniqueSet = `1` << `2`,
5683	MultiEntrySet = `1` << `3`,
5684	AllFieldsSet = (NameSet \| KeyPathSet \| UniqueSet \| MultiEntrySet)
5685	};
5686
5687	template<int STATE>
5688	class Builder {
5689	private:
5690	RefPtr<JSON::Object> m_result;
5691
5692	template<int STEP> Builder<STATE \| STEP>& castState()
5693	{
5694	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
5695	}
5696
5697	Builder(Ref</ObjectStoreIndex/JSON::Object>&& object)
5698	: m_result (WTFMove(object))
5699	{
5700	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5701	}
5702	friend class ObjectStoreIndex;
5703	public:
5704
5705	Builder<STATE \| NameSet>& setName(const String& in_name)
5706	{
5707	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
5708	m_result ->setString("name"_s, in_name);
5709	return castState<NameSet>();
5710	}
5711
5712	Builder<STATE \| KeyPathSet>& setKeyPath(Ref<Protocol::IndexedDB::KeyPath>&& in_keyPath)
5713	{
5714	COMPILE_ASSERT(!(STATE & KeyPathSet), property_keyPath_already_set);
5715	m_result ->setObject("keyPath"_s, WTFMove(in_keyPath));
5716	return castState<KeyPathSet>();
5717	}
5718
5719	Builder<STATE \| UniqueSet>& setUnique(bool in_unique)
5720	{
5721	COMPILE_ASSERT(!(STATE & UniqueSet), property_unique_already_set);
5722	m_result ->setBoolean("unique"_s, in_unique);
5723	return castState<UniqueSet>();
5724	}
5725
5726	Builder<STATE \| MultiEntrySet>& setMultiEntry(bool in_multiEntry)
5727	{
5728	COMPILE_ASSERT(!(STATE & MultiEntrySet), property_multiEntry_already_set);
5729	m_result ->setBoolean("multiEntry"_s, in_multiEntry);
5730	return castState<MultiEntrySet>();
5731	}
5732
5733	Ref<ObjectStoreIndex> release()
5734	{
5735	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5736	COMPILE_ASSERT(sizeof(ObjectStoreIndex) == sizeof(JSON::Object), cannot_cast);
5737
5738	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5739	auto result = WTFMove(*reinterpret_cast<Ref<ObjectStoreIndex>*>(&jsonResult));
5740	return result;
5741	}
5742	};
5743
5744	/*
5745	* Synthetic constructor:
5746	* Ref<ObjectStoreIndex> result = ObjectStoreIndex::create()
5747	* .setName(...)
5748	* .setKeyPath(...)
5749	* .setUnique(...)
5750	* .setMultiEntry(...)
5751	* .release();
5752	*/
5753	static Builder<NoFieldsSet> create()
5754	{
5755	return Builder<NoFieldsSet>(JSON::Object::create());
5756	}
5757	};
5758
5759	/ Key. /
5760	class Key final : public JSON::Object {
5761	public:
5762	// Named after property name 'type' while generating Key.
5763	enum class Type {
5764	Number = `132`,
5765	String = `133`,
5766	Date = `107`,
5767	Array = `134`,
5768	}; // enum class Type
5769
5770	enum {
5771	NoFieldsSet = `0`,
5772	TypeSet = `1` << `0`,
5773	AllFieldsSet = (TypeSet)
5774	};
5775
5776	template<int STATE>
5777	class Builder {
5778	private:
5779	RefPtr<JSON::Object> m_result;
5780
5781	template<int STEP> Builder<STATE \| STEP>& castState()
5782	{
5783	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
5784	}
5785
5786	Builder(Ref</Key/JSON::Object>&& object)
5787	: m_result (WTFMove(object))
5788	{
5789	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5790	}
5791	friend class Key;
5792	public:
5793
5794	Builder<STATE \| TypeSet>& setType(Type in_type)
5795	{
5796	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
5797	m_result ->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
5798	return castState<TypeSet>();
5799	}
5800
5801	Ref<Key> release()
5802	{
5803	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5804	COMPILE_ASSERT(sizeof(Key) == sizeof(JSON::Object), cannot_cast);
5805
5806	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5807	auto result = WTFMove(*reinterpret_cast<Ref<Key>*>(&jsonResult));
5808	return result;
5809	}
5810	};
5811
5812	/*
5813	* Synthetic constructor:
5814	* Ref<Key> result = Key::create()
5815	* .setType(...)
5816	* .release();
5817	*/
5818	static Builder<NoFieldsSet> create()
5819	{
5820	return Builder<NoFieldsSet>(JSON::Object::create());
5821	}
5822
5823	void setNumber(double in_opt_number)
5824	{
5825	JSON::ObjectBase::setDouble("number"_s, in_opt_number);
5826	}
5827
5828	void setString(const String& in_opt_string)
5829	{
5830	JSON::ObjectBase::setString("string"_s, in_opt_string);
5831	}
5832
5833	void setDate(double in_opt_date)
5834	{
5835	JSON::ObjectBase::setDouble("date"_s, in_opt_date);
5836	}
5837
5838	void setArray(Ref<JSON::ArrayOf<Protocol::IndexedDB::Key>>&& in_opt_array)
5839	{
5840	JSON::ObjectBase::setArray("array"_s, WTFMove(in_opt_array));
5841	}
5842
5843	// Property names for type generated as open.
5844	JS_EXPORT_PRIVATE static const ASCIILiteral typeKey;
5845	JS_EXPORT_PRIVATE static const ASCIILiteral numberKey;
5846	JS_EXPORT_PRIVATE static const ASCIILiteral stringKey;
5847	JS_EXPORT_PRIVATE static const ASCIILiteral dateKey;
5848	JS_EXPORT_PRIVATE static const ASCIILiteral arrayKey;
5849	};
5850
5851	/ Key range. /
5852	class KeyRange final : public JSON::Object {
5853	public:
5854	enum {
5855	NoFieldsSet = `0`,
5856	LowerOpenSet = `1` << `0`,
5857	UpperOpenSet = `1` << `1`,
5858	AllFieldsSet = (LowerOpenSet \| UpperOpenSet)
5859	};
5860
5861	template<int STATE>
5862	class Builder {
5863	private:
5864	RefPtr<JSON::Object> m_result;
5865
5866	template<int STEP> Builder<STATE \| STEP>& castState()
5867	{
5868	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
5869	}
5870
5871	Builder(Ref</KeyRange/JSON::Object>&& object)
5872	: m_result (WTFMove(object))
5873	{
5874	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5875	}
5876	friend class KeyRange;
5877	public:
5878
5879	Builder<STATE \| LowerOpenSet>& setLowerOpen(bool in_lowerOpen)
5880	{
5881	COMPILE_ASSERT(!(STATE & LowerOpenSet), property_lowerOpen_already_set);
5882	m_result ->setBoolean("lowerOpen"_s, in_lowerOpen);
5883	return castState<LowerOpenSet>();
5884	}
5885
5886	Builder<STATE \| UpperOpenSet>& setUpperOpen(bool in_upperOpen)
5887	{
5888	COMPILE_ASSERT(!(STATE & UpperOpenSet), property_upperOpen_already_set);
5889	m_result ->setBoolean("upperOpen"_s, in_upperOpen);
5890	return castState<UpperOpenSet>();
5891	}
5892
5893	Ref<KeyRange> release()
5894	{
5895	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5896	COMPILE_ASSERT(sizeof(KeyRange) == sizeof(JSON::Object), cannot_cast);
5897
5898	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5899	auto result = WTFMove(*reinterpret_cast<Ref<KeyRange>*>(&jsonResult));
5900	return result;
5901	}
5902	};
5903
5904	/*
5905	* Synthetic constructor:
5906	* Ref<KeyRange> result = KeyRange::create()
5907	* .setLowerOpen(...)
5908	* .setUpperOpen(...)
5909	* .release();
5910	*/
5911	static Builder<NoFieldsSet> create()
5912	{
5913	return Builder<NoFieldsSet>(JSON::Object::create());
5914	}
5915
5916	void setLower(Ref<Protocol::IndexedDB::Key>&& in_opt_lower)
5917	{
5918	JSON::ObjectBase::setObject("lower"_s, WTFMove(in_opt_lower));
5919	}
5920
5921	void setUpper(Ref<Protocol::IndexedDB::Key>&& in_opt_upper)
5922	{
5923	JSON::ObjectBase::setObject("upper"_s, WTFMove(in_opt_upper));
5924	}
5925
5926	// Property names for type generated as open.
5927	JS_EXPORT_PRIVATE static const ASCIILiteral lowerKey;
5928	JS_EXPORT_PRIVATE static const ASCIILiteral upperKey;
5929	JS_EXPORT_PRIVATE static const ASCIILiteral lowerOpenKey;
5930	JS_EXPORT_PRIVATE static const ASCIILiteral upperOpenKey;
5931	};
5932
5933	/ Data entry. /
5934	class DataEntry final : public JSON::ObjectBase {
5935	public:
5936	enum {
5937	NoFieldsSet = `0`,
5938	KeySet = `1` << `0`,
5939	PrimaryKeySet = `1` << `1`,
5940	ValueSet = `1` << `2`,
5941	AllFieldsSet = (KeySet \| PrimaryKeySet \| ValueSet)
5942	};
5943
5944	template<int STATE>
5945	class Builder {
5946	private:
5947	RefPtr<JSON::Object> m_result;
5948
5949	template<int STEP> Builder<STATE \| STEP>& castState()
5950	{
5951	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
5952	}
5953
5954	Builder(Ref</DataEntry/JSON::Object>&& object)
5955	: m_result (WTFMove(object))
5956	{
5957	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5958	}
5959	friend class DataEntry;
5960	public:
5961
5962	Builder<STATE \| KeySet>& setKey(Ref<Protocol::Runtime::RemoteObject>&& in_key)
5963	{
5964	COMPILE_ASSERT(!(STATE & KeySet), property_key_already_set);
5965	m_result ->setObject("key"_s, WTFMove(in_key));
5966	return castState<KeySet>();
5967	}
5968
5969	Builder<STATE \| PrimaryKeySet>& setPrimaryKey(Ref<Protocol::Runtime::RemoteObject>&& in_primaryKey)
5970	{
5971	COMPILE_ASSERT(!(STATE & PrimaryKeySet), property_primaryKey_already_set);
5972	m_result ->setObject("primaryKey"_s, WTFMove(in_primaryKey));
5973	return castState<PrimaryKeySet>();
5974	}
5975
5976	Builder<STATE \| ValueSet>& setValue(Ref<Protocol::Runtime::RemoteObject>&& in_value)
5977	{
5978	COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set);
5979	m_result ->setObject("value"_s, WTFMove(in_value));
5980	return castState<ValueSet>();
5981	}
5982
5983	Ref<DataEntry> release()
5984	{
5985	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5986	COMPILE_ASSERT(sizeof(DataEntry) == sizeof(JSON::Object), cannot_cast);
5987
5988	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5989	auto result = WTFMove(*reinterpret_cast<Ref<DataEntry>*>(&jsonResult));
5990	return result;
5991	}
5992	};
5993
5994	/*
5995	* Synthetic constructor:
5996	* Ref<DataEntry> result = DataEntry::create()
5997	* .setKey(...)
5998	* .setPrimaryKey(...)
5999	* .setValue(...)
6000	* .release();
6001	*/
6002	static Builder<NoFieldsSet> create()
6003	{
6004	return Builder<NoFieldsSet>(JSON::Object::create());
6005	}
6006	};
6007
6008	/ Key path. /
6009	class KeyPath final : public JSON::ObjectBase {
6010	public:
6011	// Named after property name 'type' while generating KeyPath.
6012	enum class Type {
6013	Null = `135`,
6014	String = `133`,
6015	Array = `134`,
6016	}; // enum class Type
6017
6018	enum {
6019	NoFieldsSet = `0`,
6020	TypeSet = `1` << `0`,
6021	AllFieldsSet = (TypeSet)
6022	};
6023
6024	template<int STATE>
6025	class Builder {
6026	private:
6027	RefPtr<JSON::Object> m_result;
6028
6029	template<int STEP> Builder<STATE \| STEP>& castState()
6030	{
6031	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
6032	}
6033
6034	Builder(Ref</KeyPath/JSON::Object>&& object)
6035	: m_result (WTFMove(object))
6036	{
6037	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6038	}
6039	friend class KeyPath;
6040	public:
6041
6042	Builder<STATE \| TypeSet>& setType(Type in_type)
6043	{
6044	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
6045	m_result ->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
6046	return castState<TypeSet>();
6047	}
6048
6049	Ref<KeyPath> release()
6050	{
6051	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6052	COMPILE_ASSERT(sizeof(KeyPath) == sizeof(JSON::Object), cannot_cast);
6053
6054	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6055	auto result = WTFMove(*reinterpret_cast<Ref<KeyPath>*>(&jsonResult));
6056	return result;
6057	}
6058	};
6059
6060	/*
6061	* Synthetic constructor:
6062	* Ref<KeyPath> result = KeyPath::create()
6063	* .setType(...)
6064	* .release();
6065	*/
6066	static Builder<NoFieldsSet> create()
6067	{
6068	return Builder<NoFieldsSet>(JSON::Object::create());
6069	}
6070
6071	void setString(const String& in_opt_string)
6072	{
6073	JSON::ObjectBase::setString("string"_s, in_opt_string);
6074	}
6075
6076	void setArray(Ref<JSON::ArrayOf<String>>&& in_opt_array)
6077	{
6078	JSON::ObjectBase::setArray("array"_s, WTFMove(in_opt_array));
6079	}
6080	};
6081
6082	} // IndexedDB
6083
6084	namespace LayerTree {
6085
6086	/ A rectangle. /
6087	class IntRect final : public JSON::ObjectBase {
6088	public:
6089	enum {
6090	NoFieldsSet = `0`,
6091	XSet = `1` << `0`,
6092	YSet = `1` << `1`,
6093	WidthSet = `1` << `2`,
6094	HeightSet = `1` << `3`,
6095	AllFieldsSet = (XSet \| YSet \| WidthSet \| HeightSet)
6096	};
6097
6098	template<int STATE>
6099	class Builder {
6100	private:
6101	RefPtr<JSON::Object> m_result;
6102
6103	template<int STEP> Builder<STATE \| STEP>& castState()
6104	{
6105	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
6106	}
6107
6108	Builder(Ref</IntRect/JSON::Object>&& object)
6109	: m_result (WTFMove(object))
6110	{
6111	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6112	}
6113	friend class IntRect;
6114	public:
6115
6116	Builder<STATE \| XSet>& setX(int in_x)
6117	{
6118	COMPILE_ASSERT(!(STATE & XSet), property_x_already_set);
6119	m_result ->setInteger("x"_s, in_x);
6120	return castState<XSet>();
6121	}
6122
6123	Builder<STATE \| YSet>& setY(int in_y)
6124	{
6125	COMPILE_ASSERT(!(STATE & YSet), property_y_already_set);
6126	m_result ->setInteger("y"_s, in_y);
6127	return castState<YSet>();
6128	}
6129
6130	Builder<STATE \| WidthSet>& setWidth(int in_width)
6131	{
6132	COMPILE_ASSERT(!(STATE & WidthSet), property_width_already_set);
6133	m_result ->setInteger("width"_s, in_width);
6134	return castState<WidthSet>();
6135	}
6136
6137	Builder<STATE \| HeightSet>& setHeight(int in_height)
6138	{
6139	COMPILE_ASSERT(!(STATE & HeightSet), property_height_already_set);
6140	m_result ->setInteger("height"_s, in_height);
6141	return castState<HeightSet>();
6142	}
6143
6144	Ref<IntRect> release()
6145	{
6146	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6147	COMPILE_ASSERT(sizeof(IntRect) == sizeof(JSON::Object), cannot_cast);
6148
6149	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6150	auto result = WTFMove(*reinterpret_cast<Ref<IntRect>*>(&jsonResult));
6151	return result;
6152	}
6153	};
6154
6155	/*
6156	* Synthetic constructor:
6157	* Ref<IntRect> result = IntRect::create()
6158	* .setX(...)
6159	* .setY(...)
6160	* .setWidth(...)
6161	* .setHeight(...)
6162	* .release();
6163	*/
6164	static Builder<NoFieldsSet> create()
6165	{
6166	return Builder<NoFieldsSet>(JSON::Object::create());
6167	}
6168	};
6169
6170	/ Information about a compositing layer. /
6171	class Layer final : public JSON::ObjectBase {
6172	public:
6173	enum {
6174	NoFieldsSet = `0`,
6175	LayerIdSet = `1` << `0`,
6176	NodeIdSet = `1` << `1`,
6177	BoundsSet = `1` << `2`,
6178	PaintCountSet = `1` << `3`,
6179	MemorySet = `1` << `4`,
6180	CompositedBoundsSet = `1` << `5`,
6181	AllFieldsSet = (LayerIdSet \| NodeIdSet \| BoundsSet \| PaintCountSet \| MemorySet \| CompositedBoundsSet)
6182	};
6183
6184	template<int STATE>
6185	class Builder {
6186	private:
6187	RefPtr<JSON::Object> m_result;
6188
6189	template<int STEP> Builder<STATE \| STEP>& castState()
6190	{
6191	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
6192	}
6193
6194	Builder(Ref</Layer/JSON::Object>&& object)
6195	: m_result (WTFMove(object))
6196	{
6197	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6198	}
6199	friend class Layer;
6200	public:
6201
6202	Builder<STATE \| LayerIdSet>& setLayerId(const String& in_layerId)
6203	{
6204	COMPILE_ASSERT(!(STATE & LayerIdSet), property_layerId_already_set);
6205	m_result ->setString("layerId"_s, in_layerId);
6206	return castState<LayerIdSet>();
6207	}
6208
6209	Builder<STATE \| NodeIdSet>& setNodeId(int in_nodeId)
6210	{
6211	COMPILE_ASSERT(!(STATE & NodeIdSet), property_nodeId_already_set);
6212	m_result ->setInteger("nodeId"_s, in_nodeId);
6213	return castState<NodeIdSet>();
6214	}
6215
6216	Builder<STATE \| BoundsSet>& setBounds(Ref<Protocol::LayerTree::IntRect>&& in_bounds)
6217	{
6218	COMPILE_ASSERT(!(STATE & BoundsSet), property_bounds_already_set);
6219	m_result ->setObject("bounds"_s, WTFMove(in_bounds));
6220	return castState<BoundsSet>();
6221	}
6222
6223	Builder<STATE \| PaintCountSet>& setPaintCount(int in_paintCount)
6224	{
6225	COMPILE_ASSERT(!(STATE & PaintCountSet), property_paintCount_already_set);
6226	m_result ->setInteger("paintCount"_s, in_paintCount);
6227	return castState<PaintCountSet>();
6228	}
6229
6230	Builder<STATE \| MemorySet>& setMemory(int in_memory)
6231	{
6232	COMPILE_ASSERT(!(STATE & MemorySet), property_memory_already_set);
6233	m_result ->setInteger("memory"_s, in_memory);
6234	return castState<MemorySet>();
6235	}
6236
6237	Builder<STATE \| CompositedBoundsSet>& setCompositedBounds(Ref<Protocol::LayerTree::IntRect>&& in_compositedBounds)
6238	{
6239	COMPILE_ASSERT(!(STATE & CompositedBoundsSet), property_compositedBounds_already_set);
6240	m_result ->setObject("compositedBounds"_s, WTFMove(in_compositedBounds));
6241	return castState<CompositedBoundsSet>();
6242	}
6243
6244	Ref<Layer> release()
6245	{
6246	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6247	COMPILE_ASSERT(sizeof(Layer) == sizeof(JSON::Object), cannot_cast);
6248
6249	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6250	auto result = WTFMove(*reinterpret_cast<Ref<Layer>*>(&jsonResult));
6251	return result;
6252	}
6253	};
6254
6255	/*
6256	* Synthetic constructor:
6257	* Ref<Layer> result = Layer::create()
6258	* .setLayerId(...)
6259	* .setNodeId(...)
6260	* .setBounds(...)
6261	* .setPaintCount(...)
6262	* .setMemory(...)
6263	* .setCompositedBounds(...)
6264	* .release();
6265	*/
6266	static Builder<NoFieldsSet> create()
6267	{
6268	return Builder<NoFieldsSet>(JSON::Object::create());
6269	}
6270
6271	void setIsInShadowTree(bool in_opt_isInShadowTree)
6272	{
6273	JSON::ObjectBase::setBoolean("isInShadowTree"_s, in_opt_isInShadowTree);
6274	}
6275
6276	void setIsReflection(bool in_opt_isReflection)
6277	{
6278	JSON::ObjectBase::setBoolean("isReflection"_s, in_opt_isReflection);
6279	}
6280
6281	void setIsGeneratedContent(bool in_opt_isGeneratedContent)
6282	{
6283	JSON::ObjectBase::setBoolean("isGeneratedContent"_s, in_opt_isGeneratedContent);
6284	}
6285
6286	void setIsAnonymous(bool in_opt_isAnonymous)
6287	{
6288	JSON::ObjectBase::setBoolean("isAnonymous"_s, in_opt_isAnonymous);
6289	}
6290
6291	void setPseudoElementId(const String& in_opt_pseudoElementId)
6292	{
6293	JSON::ObjectBase::setString("pseudoElementId"_s, in_opt_pseudoElementId);
6294	}
6295
6296	void setPseudoElement(const String& in_opt_pseudoElement)
6297	{
6298	JSON::ObjectBase::setString("pseudoElement"_s, in_opt_pseudoElement);
6299	}
6300	};
6301
6302	/ An object containing the reasons why the layer was composited as properties. /
6303	class CompositingReasons final : public JSON::ObjectBase {
6304	public:
6305	enum {
6306	NoFieldsSet = `0`,
6307	AllFieldsSet = `0`
6308	};
6309
6310	template<int STATE>
6311	class Builder {
6312	private:
6313	RefPtr<JSON::Object> m_result;
6314
6315	template<int STEP> Builder<STATE \| STEP>& castState()
6316	{
6317	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
6318	}
6319
6320	Builder(Ref</CompositingReasons/JSON::Object>&& object)
6321	: m_result (WTFMove(object))
6322	{
6323	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6324	}
6325	friend class CompositingReasons;
6326	public:
6327
6328	Ref<CompositingReasons> release()
6329	{
6330	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6331	COMPILE_ASSERT(sizeof(CompositingReasons) == sizeof(JSON::Object), cannot_cast);
6332
6333	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6334	auto result = WTFMove(*reinterpret_cast<Ref<CompositingReasons>*>(&jsonResult));
6335	return result;
6336	}
6337	};
6338
6339	/*
6340	* Synthetic constructor:
6341	* Ref<CompositingReasons> result = CompositingReasons::create()
6342	* .release();
6343	*/
6344	static Builder<NoFieldsSet> create()
6345	{
6346	return Builder<NoFieldsSet>(JSON::Object::create());
6347	}
6348
6349	void setTransform3D(bool in_opt_transform3D)
6350	{
6351	JSON::ObjectBase::setBoolean("transform3D"_s, in_opt_transform3D);
6352	}
6353
6354	void setVideo(bool in_opt_video)
6355	{
6356	JSON::ObjectBase::setBoolean("video"_s, in_opt_video);
6357	}
6358
6359	void setCanvas(bool in_opt_canvas)
6360	{
6361	JSON::ObjectBase::setBoolean("canvas"_s, in_opt_canvas);
6362	}
6363
6364	void setPlugin(bool in_opt_plugin)
6365	{
6366	JSON::ObjectBase::setBoolean("plugin"_s, in_opt_plugin);
6367	}
6368
6369	void setIFrame(bool in_opt_iFrame)
6370	{
6371	JSON::ObjectBase::setBoolean("iFrame"_s, in_opt_iFrame);
6372	}
6373
6374	void setModel(bool in_opt_model)
6375	{
6376	JSON::ObjectBase::setBoolean("model"_s, in_opt_model);
6377	}
6378
6379	void setBackfaceVisibilityHidden(bool in_opt_backfaceVisibilityHidden)
6380	{
6381	JSON::ObjectBase::setBoolean("backfaceVisibilityHidden"_s, in_opt_backfaceVisibilityHidden);
6382	}
6383
6384	void setClipsCompositingDescendants(bool in_opt_clipsCompositingDescendants)
6385	{
6386	JSON::ObjectBase::setBoolean("clipsCompositingDescendants"_s, in_opt_clipsCompositingDescendants);
6387	}
6388
6389	void setAnimation(bool in_opt_animation)
6390	{
6391	JSON::ObjectBase::setBoolean("animation"_s, in_opt_animation);
6392	}
6393
6394	void setFilters(bool in_opt_filters)
6395	{
6396	JSON::ObjectBase::setBoolean("filters"_s, in_opt_filters);
6397	}
6398
6399	void setPositionFixed(bool in_opt_positionFixed)
6400	{
6401	JSON::ObjectBase::setBoolean("positionFixed"_s, in_opt_positionFixed);
6402	}
6403
6404	void setPositionSticky(bool in_opt_positionSticky)
6405	{
6406	JSON::ObjectBase::setBoolean("positionSticky"_s, in_opt_positionSticky);
6407	}
6408
6409	void setOverflowScrollingTouch(bool in_opt_overflowScrollingTouch)
6410	{
6411	JSON::ObjectBase::setBoolean("overflowScrollingTouch"_s, in_opt_overflowScrollingTouch);
6412	}
6413
6414	void setStacking(bool in_opt_stacking)
6415	{
6416	JSON::ObjectBase::setBoolean("stacking"_s, in_opt_stacking);
6417	}
6418
6419	void setOverlap(bool in_opt_overlap)
6420	{
6421	JSON::ObjectBase::setBoolean("overlap"_s, in_opt_overlap);
6422	}
6423
6424	void setNegativeZIndexChildren(bool in_opt_negativeZIndexChildren)
6425	{
6426	JSON::ObjectBase::setBoolean("negativeZIndexChildren"_s, in_opt_negativeZIndexChildren);
6427	}
6428
6429	void setTransformWithCompositedDescendants(bool in_opt_transformWithCompositedDescendants)
6430	{
6431	JSON::ObjectBase::setBoolean("transformWithCompositedDescendants"_s, in_opt_transformWithCompositedDescendants);
6432	}
6433
6434	void setOpacityWithCompositedDescendants(bool in_opt_opacityWithCompositedDescendants)
6435	{
6436	JSON::ObjectBase::setBoolean("opacityWithCompositedDescendants"_s, in_opt_opacityWithCompositedDescendants);
6437	}
6438
6439	void setMaskWithCompositedDescendants(bool in_opt_maskWithCompositedDescendants)
6440	{
6441	JSON::ObjectBase::setBoolean("maskWithCompositedDescendants"_s, in_opt_maskWithCompositedDescendants);
6442	}
6443
6444	void setReflectionWithCompositedDescendants(bool in_opt_reflectionWithCompositedDescendants)
6445	{
6446	JSON::ObjectBase::setBoolean("reflectionWithCompositedDescendants"_s, in_opt_reflectionWithCompositedDescendants);
6447	}
6448
6449	void setFilterWithCompositedDescendants(bool in_opt_filterWithCompositedDescendants)
6450	{
6451	JSON::ObjectBase::setBoolean("filterWithCompositedDescendants"_s, in_opt_filterWithCompositedDescendants);
6452	}
6453
6454	void setBlendingWithCompositedDescendants(bool in_opt_blendingWithCompositedDescendants)
6455	{
6456	JSON::ObjectBase::setBoolean("blendingWithCompositedDescendants"_s, in_opt_blendingWithCompositedDescendants);
6457	}
6458
6459	void setIsolatesCompositedBlendingDescendants(bool in_opt_isolatesCompositedBlendingDescendants)
6460	{
6461	JSON::ObjectBase::setBoolean("isolatesCompositedBlendingDescendants"_s, in_opt_isolatesCompositedBlendingDescendants);
6462	}
6463
6464	void setPerspective(bool in_opt_perspective)
6465	{
6466	JSON::ObjectBase::setBoolean("perspective"_s, in_opt_perspective);
6467	}
6468
6469	void setPreserve3D(bool in_opt_preserve3D)
6470	{
6471	JSON::ObjectBase::setBoolean("preserve3D"_s, in_opt_preserve3D);
6472	}
6473
6474	void setWillChange(bool in_opt_willChange)
6475	{
6476	JSON::ObjectBase::setBoolean("willChange"_s, in_opt_willChange);
6477	}
6478
6479	void setRoot(bool in_opt_root)
6480	{
6481	JSON::ObjectBase::setBoolean("root"_s, in_opt_root);
6482	}
6483
6484	void setBlending(bool in_opt_blending)
6485	{
6486	JSON::ObjectBase::setBoolean("blending"_s, in_opt_blending);
6487	}
6488	};
6489
6490	} // LayerTree
6491
6492	#if defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE
6493	namespace Memory {
6494
6495	class Event final : public JSON::ObjectBase {
6496	public:
6497	enum {
6498	NoFieldsSet = `0`,
6499	TimestampSet = `1` << `0`,
6500	CategoriesSet = `1` << `1`,
6501	AllFieldsSet = (TimestampSet \| CategoriesSet)
6502	};
6503
6504	template<int STATE>
6505	class Builder {
6506	private:
6507	RefPtr<JSON::Object> m_result;
6508
6509	template<int STEP> Builder<STATE \| STEP>& castState()
6510	{
6511	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
6512	}
6513
6514	Builder(Ref</Event/JSON::Object>&& object)
6515	: m_result (WTFMove(object))
6516	{
6517	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6518	}
6519	friend class Event;
6520	public:
6521
6522	Builder<STATE \| TimestampSet>& setTimestamp(double in_timestamp)
6523	{
6524	COMPILE_ASSERT(!(STATE & TimestampSet), property_timestamp_already_set);
6525	m_result ->setDouble("timestamp"_s, in_timestamp);
6526	return castState<TimestampSet>();
6527	}
6528
6529	Builder<STATE \| CategoriesSet>& setCategories(Ref<JSON::ArrayOf<Protocol::Memory::CategoryData>>&& in_categories)
6530	{
6531	COMPILE_ASSERT(!(STATE & CategoriesSet), property_categories_already_set);
6532	m_result ->setArray("categories"_s, WTFMove(in_categories));
6533	return castState<CategoriesSet>();
6534	}
6535
6536	Ref<Event> release()
6537	{
6538	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6539	COMPILE_ASSERT(sizeof(Event) == sizeof(JSON::Object), cannot_cast);
6540
6541	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6542	auto result = WTFMove(*reinterpret_cast<Ref<Event>*>(&jsonResult));
6543	return result;
6544	}
6545	};
6546
6547	/*
6548	* Synthetic constructor:
6549	* Ref<Event> result = Event::create()
6550	* .setTimestamp(...)
6551	* .setCategories(...)
6552	* .release();
6553	*/
6554	static Builder<NoFieldsSet> create()
6555	{
6556	return Builder<NoFieldsSet>(JSON::Object::create());
6557	}
6558	};
6559
6560	class CategoryData final : public JSON::ObjectBase {
6561	public:
6562	// Named after property name 'type' while generating CategoryData.
6563	enum class Type {
6564	JavaScript = `55`,
6565	JIT = `136`,
6566	Images = `137`,
6567	Layers = `138`,
6568	Page = `104`,
6569	Other = `70`,
6570	}; // enum class Type
6571
6572	enum {
6573	NoFieldsSet = `0`,
6574	TypeSet = `1` << `0`,
6575	SizeSet = `1` << `1`,
6576	AllFieldsSet = (TypeSet \| SizeSet)
6577	};
6578
6579	template<int STATE>
6580	class Builder {
6581	private:
6582	RefPtr<JSON::Object> m_result;
6583
6584	template<int STEP> Builder<STATE \| STEP>& castState()
6585	{
6586	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
6587	}
6588
6589	Builder(Ref</CategoryData/JSON::Object>&& object)
6590	: m_result (WTFMove(object))
6591	{
6592	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6593	}
6594	friend class CategoryData;
6595	public:
6596
6597	Builder<STATE \| TypeSet>& setType(Type in_type)
6598	{
6599	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
6600	m_result ->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
6601	return castState<TypeSet>();
6602	}
6603
6604	Builder<STATE \| SizeSet>& setSize(double in_size)
6605	{
6606	COMPILE_ASSERT(!(STATE & SizeSet), property_size_already_set);
6607	m_result ->setDouble("size"_s, in_size);
6608	return castState<SizeSet>();
6609	}
6610
6611	Ref<CategoryData> release()
6612	{
6613	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6614	COMPILE_ASSERT(sizeof(CategoryData) == sizeof(JSON::Object), cannot_cast);
6615
6616	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6617	auto result = WTFMove(*reinterpret_cast<Ref<CategoryData>*>(&jsonResult));
6618	return result;
6619	}
6620	};
6621
6622	/*
6623	* Synthetic constructor:
6624	* Ref<CategoryData> result = CategoryData::create()
6625	* .setType(...)
6626	* .setSize(...)
6627	* .release();
6628	*/
6629	static Builder<NoFieldsSet> create()
6630	{
6631	return Builder<NoFieldsSet>(JSON::Object::create());
6632	}
6633	};
6634
6635	} // Memory
6636	#endif // defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE
6637
6638	namespace Network {
6639
6640	/ Request / response headers as keys / values of JSON object. /
6641	class Headers final : public JSON::ObjectBase {
6642	public:
6643	enum {
6644	NoFieldsSet = `0`,
6645	AllFieldsSet = `0`
6646	};
6647
6648	template<int STATE>
6649	class Builder {
6650	private:
6651	RefPtr<JSON::Object> m_result;
6652
6653	template<int STEP> Builder<STATE \| STEP>& castState()
6654	{
6655	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
6656	}
6657
6658	Builder(Ref</Headers/JSON::Object>&& object)
6659	: m_result (WTFMove(object))
6660	{
6661	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6662	}
6663	friend class Headers;
6664	public:
6665
6666	Ref<Headers> release()
6667	{
6668	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6669	COMPILE_ASSERT(sizeof(Headers) == sizeof(JSON::Object), cannot_cast);
6670
6671	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6672	auto result = WTFMove(*reinterpret_cast<Ref<Headers>*>(&jsonResult));
6673	return result;
6674	}
6675	};
6676
6677	/*
6678	* Synthetic constructor:
6679	* Ref<Headers> result = Headers::create()
6680	* .release();
6681	*/
6682	static Builder<NoFieldsSet> create()
6683	{
6684	return Builder<NoFieldsSet>(JSON::Object::create());
6685	}
6686	};
6687
6688	/ Timing information for the request. /
6689	class ResourceTiming final : public JSON::ObjectBase {
6690	public:
6691	enum {
6692	NoFieldsSet = `0`,
6693	StartTimeSet = `1` << `0`,
6694	RedirectStartSet = `1` << `1`,
6695	RedirectEndSet = `1` << `2`,
6696	FetchStartSet = `1` << `3`,
6697	DomainLookupStartSet = `1` << `4`,
6698	DomainLookupEndSet = `1` << `5`,
6699	ConnectStartSet = `1` << `6`,
6700	ConnectEndSet = `1` << `7`,
6701	SecureConnectionStartSet = `1` << `8`,
6702	RequestStartSet = `1` << `9`,
6703	ResponseStartSet = `1` << `10`,
6704	ResponseEndSet = `1` << `11`,
6705	AllFieldsSet = (StartTimeSet \| RedirectStartSet \| RedirectEndSet \| FetchStartSet \| DomainLookupStartSet \| DomainLookupEndSet \| ConnectStartSet \| ConnectEndSet \| SecureConnectionStartSet \| RequestStartSet \| ResponseStartSet \| ResponseEndSet)
6706	};
6707
6708	template<int STATE>
6709	class Builder {
6710	private:
6711	RefPtr<JSON::Object> m_result;
6712
6713	template<int STEP> Builder<STATE \| STEP>& castState()
6714	{
6715	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
6716	}
6717
6718	Builder(Ref</ResourceTiming/JSON::Object>&& object)
6719	: m_result (WTFMove(object))
6720	{
6721	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6722	}
6723	friend class ResourceTiming;
6724	public:
6725
6726	Builder<STATE \| StartTimeSet>& setStartTime(double in_startTime)
6727	{
6728	COMPILE_ASSERT(!(STATE & StartTimeSet), property_startTime_already_set);
6729	m_result ->setDouble("startTime"_s, in_startTime);
6730	return castState<StartTimeSet>();
6731	}
6732
6733	Builder<STATE \| RedirectStartSet>& setRedirectStart(double in_redirectStart)
6734	{
6735	COMPILE_ASSERT(!(STATE & RedirectStartSet), property_redirectStart_already_set);
6736	m_result ->setDouble("redirectStart"_s, in_redirectStart);
6737	return castState<RedirectStartSet>();
6738	}
6739
6740	Builder<STATE \| RedirectEndSet>& setRedirectEnd(double in_redirectEnd)
6741	{
6742	COMPILE_ASSERT(!(STATE & RedirectEndSet), property_redirectEnd_already_set);
6743	m_result ->setDouble("redirectEnd"_s, in_redirectEnd);
6744	return castState<RedirectEndSet>();
6745	}
6746
6747	Builder<STATE \| FetchStartSet>& setFetchStart(double in_fetchStart)
6748	{
6749	COMPILE_ASSERT(!(STATE & FetchStartSet), property_fetchStart_already_set);
6750	m_result ->setDouble("fetchStart"_s, in_fetchStart);
6751	return castState<FetchStartSet>();
6752	}
6753
6754	Builder<STATE \| DomainLookupStartSet>& setDomainLookupStart(double in_domainLookupStart)
6755	{
6756	COMPILE_ASSERT(!(STATE & DomainLookupStartSet), property_domainLookupStart_already_set);
6757	m_result ->setDouble("domainLookupStart"_s, in_domainLookupStart);
6758	return castState<DomainLookupStartSet>();
6759	}
6760
6761	Builder<STATE \| DomainLookupEndSet>& setDomainLookupEnd(double in_domainLookupEnd)
6762	{
6763	COMPILE_ASSERT(!(STATE & DomainLookupEndSet), property_domainLookupEnd_already_set);
6764	m_result ->setDouble("domainLookupEnd"_s, in_domainLookupEnd);
6765	return castState<DomainLookupEndSet>();
6766	}
6767
6768	Builder<STATE \| ConnectStartSet>& setConnectStart(double in_connectStart)
6769	{
6770	COMPILE_ASSERT(!(STATE & ConnectStartSet), property_connectStart_already_set);
6771	m_result ->setDouble("connectStart"_s, in_connectStart);
6772	return castState<ConnectStartSet>();
6773	}
6774
6775	Builder<STATE \| ConnectEndSet>& setConnectEnd(double in_connectEnd)
6776	{
6777	COMPILE_ASSERT(!(STATE & ConnectEndSet), property_connectEnd_already_set);
6778	m_result ->setDouble("connectEnd"_s, in_connectEnd);
6779	return castState<ConnectEndSet>();
6780	}
6781
6782	Builder<STATE \| SecureConnectionStartSet>& setSecureConnectionStart(double in_secureConnectionStart)
6783	{
6784	COMPILE_ASSERT(!(STATE & SecureConnectionStartSet), property_secureConnectionStart_already_set);
6785	m_result ->setDouble("secureConnectionStart"_s, in_secureConnectionStart);
6786	return castState<SecureConnectionStartSet>();
6787	}
6788
6789	Builder<STATE \| RequestStartSet>& setRequestStart(double in_requestStart)
6790	{
6791	COMPILE_ASSERT(!(STATE & RequestStartSet), property_requestStart_already_set);
6792	m_result ->setDouble("requestStart"_s, in_requestStart);
6793	return castState<RequestStartSet>();
6794	}
6795
6796	Builder<STATE \| ResponseStartSet>& setResponseStart(double in_responseStart)
6797	{
6798	COMPILE_ASSERT(!(STATE & ResponseStartSet), property_responseStart_already_set);
6799	m_result ->setDouble("responseStart"_s, in_responseStart);
6800	return castState<ResponseStartSet>();
6801	}
6802
6803	Builder<STATE \| ResponseEndSet>& setResponseEnd(double in_responseEnd)
6804	{
6805	COMPILE_ASSERT(!(STATE & ResponseEndSet), property_responseEnd_already_set);
6806	m_result ->setDouble("responseEnd"_s, in_responseEnd);
6807	return castState<ResponseEndSet>();
6808	}
6809
6810	Ref<ResourceTiming> release()
6811	{
6812	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6813	COMPILE_ASSERT(sizeof(ResourceTiming) == sizeof(JSON::Object), cannot_cast);
6814
6815	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6816	auto result = WTFMove(*reinterpret_cast<Ref<ResourceTiming>*>(&jsonResult));
6817	return result;
6818	}
6819	};
6820
6821	/*
6822	* Synthetic constructor:
6823	* Ref<ResourceTiming> result = ResourceTiming::create()
6824	* .setStartTime(...)
6825	* .setRedirectStart(...)
6826	* .setRedirectEnd(...)
6827	* .setFetchStart(...)
6828	* .setDomainLookupStart(...)
6829	* .setDomainLookupEnd(...)
6830	* .setConnectStart(...)
6831	* .setConnectEnd(...)
6832	* .setSecureConnectionStart(...)
6833	* .setRequestStart(...)
6834	* .setResponseStart(...)
6835	* .setResponseEnd(...)
6836	* .release();
6837	*/
6838	static Builder<NoFieldsSet> create()
6839	{
6840	return Builder<NoFieldsSet>(JSON::Object::create());
6841	}
6842	};
6843
6844	/ HTTP request data. /
6845	class Request final : public JSON::ObjectBase {
6846	public:
6847	enum {
6848	NoFieldsSet = `0`,
6849	UrlSet = `1` << `0`,
6850	MethodSet = `1` << `1`,
6851	HeadersSet = `1` << `2`,
6852	AllFieldsSet = (UrlSet \| MethodSet \| HeadersSet)
6853	};
6854
6855	template<int STATE>
6856	class Builder {
6857	private:
6858	RefPtr<JSON::Object> m_result;
6859
6860	template<int STEP> Builder<STATE \| STEP>& castState()
6861	{
6862	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
6863	}
6864
6865	Builder(Ref</Request/JSON::Object>&& object)
6866	: m_result (WTFMove(object))
6867	{
6868	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6869	}
6870	friend class Request;
6871	public:
6872
6873	Builder<STATE \| UrlSet>& setUrl(const String& in_url)
6874	{
6875	COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
6876	m_result ->setString("url"_s, in_url);
6877	return castState<UrlSet>();
6878	}
6879
6880	Builder<STATE \| MethodSet>& setMethod(const String& in_method)
6881	{
6882	COMPILE_ASSERT(!(STATE & MethodSet), property_method_already_set);
6883	m_result ->setString("method"_s, in_method);
6884	return castState<MethodSet>();
6885	}
6886
6887	Builder<STATE \| HeadersSet>& setHeaders(Ref<Protocol::Network::Headers>&& in_headers)
6888	{
6889	COMPILE_ASSERT(!(STATE & HeadersSet), property_headers_already_set);
6890	m_result ->setObject("headers"_s, WTFMove(in_headers));
6891	return castState<HeadersSet>();
6892	}
6893
6894	Ref<Request> release()
6895	{
6896	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6897	COMPILE_ASSERT(sizeof(Request) == sizeof(JSON::Object), cannot_cast);
6898
6899	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6900	auto result = WTFMove(*reinterpret_cast<Ref<Request>*>(&jsonResult));
6901	return result;
6902	}
6903	};
6904
6905	/*
6906	* Synthetic constructor:
6907	* Ref<Request> result = Request::create()
6908	* .setUrl(...)
6909	* .setMethod(...)
6910	* .setHeaders(...)
6911	* .release();
6912	*/
6913	static Builder<NoFieldsSet> create()
6914	{
6915	return Builder<NoFieldsSet>(JSON::Object::create());
6916	}
6917
6918	void setPostData(const String& in_opt_postData)
6919	{
6920	JSON::ObjectBase::setString("postData"_s, in_opt_postData);
6921	}
6922	};
6923
6924	/ HTTP response data. /
6925	class Response final : public JSON::Object {
6926	public:
6927	// Named after property name 'source' while generating Response.
6928	enum class Source {
6929	Unknown = `139`,
6930	Network = `56`,
6931	MemoryCache = `140`,
6932	DiskCache = `141`,
6933	ServiceWorker = `142`,
6934	InspectorOverride = `143`,
6935	}; // enum class Source
6936
6937	enum {
6938	NoFieldsSet = `0`,
6939	UrlSet = `1` << `0`,
6940	StatusSet = `1` << `1`,
6941	StatusTextSet = `1` << `2`,
6942	HeadersSet = `1` << `3`,
6943	MimeTypeSet = `1` << `4`,
6944	SourceSet = `1` << `5`,
6945	AllFieldsSet = (UrlSet \| StatusSet \| StatusTextSet \| HeadersSet \| MimeTypeSet \| SourceSet)
6946	};
6947
6948	template<int STATE>
6949	class Builder {
6950	private:
6951	RefPtr<JSON::Object> m_result;
6952
6953	template<int STEP> Builder<STATE \| STEP>& castState()
6954	{
6955	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
6956	}
6957
6958	Builder(Ref</Response/JSON::Object>&& object)
6959	: m_result (WTFMove(object))
6960	{
6961	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6962	}
6963	friend class Response;
6964	public:
6965
6966	Builder<STATE \| UrlSet>& setUrl(const String& in_url)
6967	{
6968	COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
6969	m_result ->setString("url"_s, in_url);
6970	return castState<UrlSet>();
6971	}
6972
6973	Builder<STATE \| StatusSet>& setStatus(int in_status)
6974	{
6975	COMPILE_ASSERT(!(STATE & StatusSet), property_status_already_set);
6976	m_result ->setInteger("status"_s, in_status);
6977	return castState<StatusSet>();
6978	}
6979
6980	Builder<STATE \| StatusTextSet>& setStatusText(const String& in_statusText)
6981	{
6982	COMPILE_ASSERT(!(STATE & StatusTextSet), property_statusText_already_set);
6983	m_result ->setString("statusText"_s, in_statusText);
6984	return castState<StatusTextSet>();
6985	}
6986
6987	Builder<STATE \| HeadersSet>& setHeaders(Ref<Protocol::Network::Headers>&& in_headers)
6988	{
6989	COMPILE_ASSERT(!(STATE & HeadersSet), property_headers_already_set);
6990	m_result ->setObject("headers"_s, WTFMove(in_headers));
6991	return castState<HeadersSet>();
6992	}
6993
6994	Builder<STATE \| MimeTypeSet>& setMimeType(const String& in_mimeType)
6995	{
6996	COMPILE_ASSERT(!(STATE & MimeTypeSet), property_mimeType_already_set);
6997	m_result ->setString("mimeType"_s, in_mimeType);
6998	return castState<MimeTypeSet>();
6999	}
7000
7001	Builder<STATE \| SourceSet>& setSource(Source in_source)
7002	{
7003	COMPILE_ASSERT(!(STATE & SourceSet), property_source_already_set);
7004	m_result ->setString("source"_s, Protocol::Helpers::getEnumConstantValue(in_source));
7005	return castState<SourceSet>();
7006	}
7007
7008	Ref<Response> release()
7009	{
7010	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7011	COMPILE_ASSERT(sizeof(Response) == sizeof(JSON::Object), cannot_cast);
7012
7013	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7014	auto result = WTFMove(*reinterpret_cast<Ref<Response>*>(&jsonResult));
7015	return result;
7016	}
7017	};
7018
7019	/*
7020	* Synthetic constructor:
7021	* Ref<Response> result = Response::create()
7022	* .setUrl(...)
7023	* .setStatus(...)
7024	* .setStatusText(...)
7025	* .setHeaders(...)
7026	* .setMimeType(...)
7027	* .setSource(...)
7028	* .release();
7029	*/
7030	static Builder<NoFieldsSet> create()
7031	{
7032	return Builder<NoFieldsSet>(JSON::Object::create());
7033	}
7034
7035	void setRequestHeaders(Ref<Protocol::Network::Headers>&& in_opt_requestHeaders)
7036	{
7037	JSON::ObjectBase::setObject("requestHeaders"_s, WTFMove(in_opt_requestHeaders));
7038	}
7039
7040	void setTiming(Ref<Protocol::Network::ResourceTiming>&& in_opt_timing)
7041	{
7042	JSON::ObjectBase::setObject("timing"_s, WTFMove(in_opt_timing));
7043	}
7044
7045	void setSecurity(Ref<Protocol::Security::Security>&& in_opt_security)
7046	{
7047	JSON::ObjectBase::setObject("security"_s, WTFMove(in_opt_security));
7048	}
7049
7050	// Property names for type generated as open.
7051	JS_EXPORT_PRIVATE static const ASCIILiteral statusKey;
7052	JS_EXPORT_PRIVATE static const ASCIILiteral statusTextKey;
7053	JS_EXPORT_PRIVATE static const ASCIILiteral mimeTypeKey;
7054	JS_EXPORT_PRIVATE static const ASCIILiteral sourceKey;
7055	};
7056
7057	/ Network load metrics. /
7058	class Metrics final : public JSON::ObjectBase {
7059	public:
7060	// Named after property name 'priority' while generating Metrics.
7061	enum class Priority {
7062	Low = `144`,
7063	Medium = `145`,
7064	High = `146`,
7065	}; // enum class Priority
7066
7067	enum {
7068	NoFieldsSet = `0`,
7069	AllFieldsSet = `0`
7070	};
7071
7072	template<int STATE>
7073	class Builder {
7074	private:
7075	RefPtr<JSON::Object> m_result;
7076
7077	template<int STEP> Builder<STATE \| STEP>& castState()
7078	{
7079	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
7080	}
7081
7082	Builder(Ref</Metrics/JSON::Object>&& object)
7083	: m_result (WTFMove(object))
7084	{
7085	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7086	}
7087	friend class Metrics;
7088	public:
7089
7090	Ref<Metrics> release()
7091	{
7092	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7093	COMPILE_ASSERT(sizeof(Metrics) == sizeof(JSON::Object), cannot_cast);
7094
7095	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7096	auto result = WTFMove(*reinterpret_cast<Ref<Metrics>*>(&jsonResult));
7097	return result;
7098	}
7099	};
7100
7101	/*
7102	* Synthetic constructor:
7103	* Ref<Metrics> result = Metrics::create()
7104	* .release();
7105	*/
7106	static Builder<NoFieldsSet> create()
7107	{
7108	return Builder<NoFieldsSet>(JSON::Object::create());
7109	}
7110
7111	void setProtocol(const String& in_opt_protocol)
7112	{
7113	JSON::ObjectBase::setString("protocol"_s, in_opt_protocol);
7114	}
7115
7116	void setPriority(Priority in_opt_priority)
7117	{
7118	JSON::ObjectBase::setString("priority"_s, Protocol::Helpers::getEnumConstantValue(in_opt_priority));
7119	}
7120
7121	void setConnectionIdentifier(const String& in_opt_connectionIdentifier)
7122	{
7123	JSON::ObjectBase::setString("connectionIdentifier"_s, in_opt_connectionIdentifier);
7124	}
7125
7126	void setRemoteAddress(const String& in_opt_remoteAddress)
7127	{
7128	JSON::ObjectBase::setString("remoteAddress"_s, in_opt_remoteAddress);
7129	}
7130
7131	void setRequestHeaders(Ref<Protocol::Network::Headers>&& in_opt_requestHeaders)
7132	{
7133	JSON::ObjectBase::setObject("requestHeaders"_s, WTFMove(in_opt_requestHeaders));
7134	}
7135
7136	void setRequestHeaderBytesSent(double in_opt_requestHeaderBytesSent)
7137	{
7138	JSON::ObjectBase::setDouble("requestHeaderBytesSent"_s, in_opt_requestHeaderBytesSent);
7139	}
7140
7141	void setRequestBodyBytesSent(double in_opt_requestBodyBytesSent)
7142	{
7143	JSON::ObjectBase::setDouble("requestBodyBytesSent"_s, in_opt_requestBodyBytesSent);
7144	}
7145
7146	void setResponseHeaderBytesReceived(double in_opt_responseHeaderBytesReceived)
7147	{
7148	JSON::ObjectBase::setDouble("responseHeaderBytesReceived"_s, in_opt_responseHeaderBytesReceived);
7149	}
7150
7151	void setResponseBodyBytesReceived(double in_opt_responseBodyBytesReceived)
7152	{
7153	JSON::ObjectBase::setDouble("responseBodyBytesReceived"_s, in_opt_responseBodyBytesReceived);
7154	}
7155
7156	void setResponseBodyDecodedSize(double in_opt_responseBodyDecodedSize)
7157	{
7158	JSON::ObjectBase::setDouble("responseBodyDecodedSize"_s, in_opt_responseBodyDecodedSize);
7159	}
7160
7161	void setSecurityConnection(Ref<Protocol::Security::Connection>&& in_opt_securityConnection)
7162	{
7163	JSON::ObjectBase::setObject("securityConnection"_s, WTFMove(in_opt_securityConnection));
7164	}
7165	};
7166
7167	/ WebSocket request data. /
7168	class WebSocketRequest final : public JSON::ObjectBase {
7169	public:
7170	enum {
7171	NoFieldsSet = `0`,
7172	HeadersSet = `1` << `0`,
7173	AllFieldsSet = (HeadersSet)
7174	};
7175
7176	template<int STATE>
7177	class Builder {
7178	private:
7179	RefPtr<JSON::Object> m_result;
7180
7181	template<int STEP> Builder<STATE \| STEP>& castState()
7182	{
7183	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
7184	}
7185
7186	Builder(Ref</WebSocketRequest/JSON::Object>&& object)
7187	: m_result (WTFMove(object))
7188	{
7189	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7190	}
7191	friend class WebSocketRequest;
7192	public:
7193
7194	Builder<STATE \| HeadersSet>& setHeaders(Ref<Protocol::Network::Headers>&& in_headers)
7195	{
7196	COMPILE_ASSERT(!(STATE & HeadersSet), property_headers_already_set);
7197	m_result ->setObject("headers"_s, WTFMove(in_headers));
7198	return castState<HeadersSet>();
7199	}
7200
7201	Ref<WebSocketRequest> release()
7202	{
7203	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7204	COMPILE_ASSERT(sizeof(WebSocketRequest) == sizeof(JSON::Object), cannot_cast);
7205
7206	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7207	auto result = WTFMove(*reinterpret_cast<Ref<WebSocketRequest>*>(&jsonResult));
7208	return result;
7209	}
7210	};
7211
7212	/*
7213	* Synthetic constructor:
7214	* Ref<WebSocketRequest> result = WebSocketRequest::create()
7215	* .setHeaders(...)
7216	* .release();
7217	*/
7218	static Builder<NoFieldsSet> create()
7219	{
7220	return Builder<NoFieldsSet>(JSON::Object::create());
7221	}
7222	};
7223
7224	/ WebSocket response data. /
7225	class WebSocketResponse final : public JSON::ObjectBase {
7226	public:
7227	enum {
7228	NoFieldsSet = `0`,
7229	StatusSet = `1` << `0`,
7230	StatusTextSet = `1` << `1`,
7231	HeadersSet = `1` << `2`,
7232	AllFieldsSet = (StatusSet \| StatusTextSet \| HeadersSet)
7233	};
7234
7235	template<int STATE>
7236	class Builder {
7237	private:
7238	RefPtr<JSON::Object> m_result;
7239
7240	template<int STEP> Builder<STATE \| STEP>& castState()
7241	{
7242	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
7243	}
7244
7245	Builder(Ref</WebSocketResponse/JSON::Object>&& object)
7246	: m_result (WTFMove(object))
7247	{
7248	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7249	}
7250	friend class WebSocketResponse;
7251	public:
7252
7253	Builder<STATE \| StatusSet>& setStatus(int in_status)
7254	{
7255	COMPILE_ASSERT(!(STATE & StatusSet), property_status_already_set);
7256	m_result ->setInteger("status"_s, in_status);
7257	return castState<StatusSet>();
7258	}
7259
7260	Builder<STATE \| StatusTextSet>& setStatusText(const String& in_statusText)
7261	{
7262	COMPILE_ASSERT(!(STATE & StatusTextSet), property_statusText_already_set);
7263	m_result ->setString("statusText"_s, in_statusText);
7264	return castState<StatusTextSet>();
7265	}
7266
7267	Builder<STATE \| HeadersSet>& setHeaders(Ref<Protocol::Network::Headers>&& in_headers)
7268	{
7269	COMPILE_ASSERT(!(STATE & HeadersSet), property_headers_already_set);
7270	m_result ->setObject("headers"_s, WTFMove(in_headers));
7271	return castState<HeadersSet>();
7272	}
7273
7274	Ref<WebSocketResponse> release()
7275	{
7276	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7277	COMPILE_ASSERT(sizeof(WebSocketResponse) == sizeof(JSON::Object), cannot_cast);
7278
7279	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7280	auto result = WTFMove(*reinterpret_cast<Ref<WebSocketResponse>*>(&jsonResult));
7281	return result;
7282	}
7283	};
7284
7285	/*
7286	* Synthetic constructor:
7287	* Ref<WebSocketResponse> result = WebSocketResponse::create()
7288	* .setStatus(...)
7289	* .setStatusText(...)
7290	* .setHeaders(...)
7291	* .release();
7292	*/
7293	static Builder<NoFieldsSet> create()
7294	{
7295	return Builder<NoFieldsSet>(JSON::Object::create());
7296	}
7297	};
7298
7299	/ WebSocket frame data. /
7300	class WebSocketFrame final : public JSON::ObjectBase {
7301	public:
7302	enum {
7303	NoFieldsSet = `0`,
7304	OpcodeSet = `1` << `0`,
7305	MaskSet = `1` << `1`,
7306	PayloadDataSet = `1` << `2`,
7307	PayloadLengthSet = `1` << `3`,
7308	AllFieldsSet = (OpcodeSet \| MaskSet \| PayloadDataSet \| PayloadLengthSet)
7309	};
7310
7311	template<int STATE>
7312	class Builder {
7313	private:
7314	RefPtr<JSON::Object> m_result;
7315
7316	template<int STEP> Builder<STATE \| STEP>& castState()
7317	{
7318	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
7319	}
7320
7321	Builder(Ref</WebSocketFrame/JSON::Object>&& object)
7322	: m_result (WTFMove(object))
7323	{
7324	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7325	}
7326	friend class WebSocketFrame;
7327	public:
7328
7329	Builder<STATE \| OpcodeSet>& setOpcode(double in_opcode)
7330	{
7331	COMPILE_ASSERT(!(STATE & OpcodeSet), property_opcode_already_set);
7332	m_result ->setDouble("opcode"_s, in_opcode);
7333	return castState<OpcodeSet>();
7334	}
7335
7336	Builder<STATE \| MaskSet>& setMask(bool in_mask)
7337	{
7338	COMPILE_ASSERT(!(STATE & MaskSet), property_mask_already_set);
7339	m_result ->setBoolean("mask"_s, in_mask);
7340	return castState<MaskSet>();
7341	}
7342
7343	Builder<STATE \| PayloadDataSet>& setPayloadData(const String& in_payloadData)
7344	{
7345	COMPILE_ASSERT(!(STATE & PayloadDataSet), property_payloadData_already_set);
7346	m_result ->setString("payloadData"_s, in_payloadData);
7347	return castState<PayloadDataSet>();
7348	}
7349
7350	Builder<STATE \| PayloadLengthSet>& setPayloadLength(double in_payloadLength)
7351	{
7352	COMPILE_ASSERT(!(STATE & PayloadLengthSet), property_payloadLength_already_set);
7353	m_result ->setDouble("payloadLength"_s, in_payloadLength);
7354	return castState<PayloadLengthSet>();
7355	}
7356
7357	Ref<WebSocketFrame> release()
7358	{
7359	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7360	COMPILE_ASSERT(sizeof(WebSocketFrame) == sizeof(JSON::Object), cannot_cast);
7361
7362	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7363	auto result = WTFMove(*reinterpret_cast<Ref<WebSocketFrame>*>(&jsonResult));
7364	return result;
7365	}
7366	};
7367
7368	/*
7369	* Synthetic constructor:
7370	* Ref<WebSocketFrame> result = WebSocketFrame::create()
7371	* .setOpcode(...)
7372	* .setMask(...)
7373	* .setPayloadData(...)
7374	* .setPayloadLength(...)
7375	* .release();
7376	*/
7377	static Builder<NoFieldsSet> create()
7378	{
7379	return Builder<NoFieldsSet>(JSON::Object::create());
7380	}
7381	};
7382
7383	/ Information about the cached resource. /
7384	class CachedResource final : public JSON::ObjectBase {
7385	public:
7386	enum {
7387	NoFieldsSet = `0`,
7388	UrlSet = `1` << `0`,
7389	TypeSet = `1` << `1`,
7390	BodySizeSet = `1` << `2`,
7391	AllFieldsSet = (UrlSet \| TypeSet \| BodySizeSet)
7392	};
7393
7394	template<int STATE>
7395	class Builder {
7396	private:
7397	RefPtr<JSON::Object> m_result;
7398
7399	template<int STEP> Builder<STATE \| STEP>& castState()
7400	{
7401	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
7402	}
7403
7404	Builder(Ref</CachedResource/JSON::Object>&& object)
7405	: m_result (WTFMove(object))
7406	{
7407	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7408	}
7409	friend class CachedResource;
7410	public:
7411
7412	Builder<STATE \| UrlSet>& setUrl(const String& in_url)
7413	{
7414	COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
7415	m_result ->setString("url"_s, in_url);
7416	return castState<UrlSet>();
7417	}
7418
7419	Builder<STATE \| TypeSet>& setType(Protocol::Page::ResourceType in_type)
7420	{
7421	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
7422	m_result ->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
7423	return castState<TypeSet>();
7424	}
7425
7426	Builder<STATE \| BodySizeSet>& setBodySize(double in_bodySize)
7427	{
7428	COMPILE_ASSERT(!(STATE & BodySizeSet), property_bodySize_already_set);
7429	m_result ->setDouble("bodySize"_s, in_bodySize);
7430	return castState<BodySizeSet>();
7431	}
7432
7433	Ref<CachedResource> release()
7434	{
7435	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7436	COMPILE_ASSERT(sizeof(CachedResource) == sizeof(JSON::Object), cannot_cast);
7437
7438	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7439	auto result = WTFMove(*reinterpret_cast<Ref<CachedResource>*>(&jsonResult));
7440	return result;
7441	}
7442	};
7443
7444	/*
7445	* Synthetic constructor:
7446	* Ref<CachedResource> result = CachedResource::create()
7447	* .setUrl(...)
7448	* .setType(...)
7449	* .setBodySize(...)
7450	* .release();
7451	*/
7452	static Builder<NoFieldsSet> create()
7453	{
7454	return Builder<NoFieldsSet>(JSON::Object::create());
7455	}
7456
7457	void setResponse(Ref<Protocol::Network::Response>&& in_opt_response)
7458	{
7459	JSON::ObjectBase::setObject("response"_s, WTFMove(in_opt_response));
7460	}
7461
7462	void setSourceMapURL(const String& in_opt_sourceMapURL)
7463	{
7464	JSON::ObjectBase::setString("sourceMapURL"_s, in_opt_sourceMapURL);
7465	}
7466	};
7467
7468	/ Information about the request initiator. /
7469	class Initiator final : public JSON::ObjectBase {
7470	public:
7471	// Named after property name 'type' while generating Initiator.
7472	enum class Type {
7473	Parser = `158`,
7474	Script = `159`,
7475	Other = `70`,
7476	}; // enum class Type
7477
7478	enum {
7479	NoFieldsSet = `0`,
7480	TypeSet = `1` << `0`,
7481	AllFieldsSet = (TypeSet)
7482	};
7483
7484	template<int STATE>
7485	class Builder {
7486	private:
7487	RefPtr<JSON::Object> m_result;
7488
7489	template<int STEP> Builder<STATE \| STEP>& castState()
7490	{
7491	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
7492	}
7493
7494	Builder(Ref</Initiator/JSON::Object>&& object)
7495	: m_result (WTFMove(object))
7496	{
7497	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7498	}
7499	friend class Initiator;
7500	public:
7501
7502	Builder<STATE \| TypeSet>& setType(Type in_type)
7503	{
7504	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
7505	m_result ->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
7506	return castState<TypeSet>();
7507	}
7508
7509	Ref<Initiator> release()
7510	{
7511	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7512	COMPILE_ASSERT(sizeof(Initiator) == sizeof(JSON::Object), cannot_cast);
7513
7514	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7515	auto result = WTFMove(*reinterpret_cast<Ref<Initiator>*>(&jsonResult));
7516	return result;
7517	}
7518	};
7519
7520	/*
7521	* Synthetic constructor:
7522	* Ref<Initiator> result = Initiator::create()
7523	* .setType(...)
7524	* .release();
7525	*/
7526	static Builder<NoFieldsSet> create()
7527	{
7528	return Builder<NoFieldsSet>(JSON::Object::create());
7529	}
7530
7531	void setStackTrace(Ref<JSON::ArrayOf<Protocol::Console::CallFrame>>&& in_opt_stackTrace)
7532	{
7533	JSON::ObjectBase::setArray("stackTrace"_s, WTFMove(in_opt_stackTrace));
7534	}
7535
7536	void setUrl(const String& in_opt_url)
7537	{
7538	JSON::ObjectBase::setString("url"_s, in_opt_url);
7539	}
7540
7541	void setLineNumber(double in_opt_lineNumber)
7542	{
7543	JSON::ObjectBase::setDouble("lineNumber"_s, in_opt_lineNumber);
7544	}
7545
7546	void setNodeId(int in_opt_nodeId)
7547	{
7548	JSON::ObjectBase::setInteger("nodeId"_s, in_opt_nodeId);
7549	}
7550	};
7551
7552	/ Different stages of a network request. /
7553	enum class NetworkStage {
7554	Request = `160`,
7555	Response = `161`,
7556	}; // enum class NetworkStage
7557
7558	/ Different stages of a network request. /
7559	enum class ResourceErrorType {
7560	General = `162`,
7561	AccessControl = `163`,
7562	Cancellation = `164`,
7563	Timeout = `165`,
7564	}; // enum class ResourceErrorType
7565
7566	} // Network
7567
7568	namespace Page {
7569
7570	/ List of settings able to be overridden by WebInspector. /
7571	enum class Setting {
7572	PrivateClickMeasurementDebugModeEnabled = `166`,
7573	AuthorAndUserStylesEnabled = `167`,
7574	ICECandidateFilteringEnabled = `168`,
7575	ITPDebugModeEnabled = `169`,
7576	ImagesEnabled = `170`,
7577	MediaCaptureRequiresSecureConnection = `171`,
7578	MockCaptureDevicesEnabled = `172`,
7579	NeedsSiteSpecificQuirks = `173`,
7580	ScriptEnabled = `174`,
7581	ShowDebugBorders = `175`,
7582	ShowRepaintCounter = `176`,
7583	WebRTCEncryptionEnabled = `177`,
7584	WebSecurityEnabled = `178`,
7585	}; // enum class Setting
7586
7587	/ Resource type as it was perceived by the rendering engine. /
7588	enum class ResourceType {
7589	Document = `147`,
7590	StyleSheet = `148`,
7591	Image = `149`,
7592	Font = `150`,
7593	Script = `151`,
7594	XHR = `152`,
7595	Fetch = `153`,
7596	Ping = `154`,
7597	Beacon = `155`,
7598	WebSocket = `156`,
7599	Other = `157`,
7600	}; // enum class ResourceType
7601
7602	/ Coordinate system used by supplied coordinates. /
7603	enum class CoordinateSystem {
7604	Viewport = `179`,
7605	Page = `180`,
7606	}; // enum class CoordinateSystem
7607
7608	/ Same-Site policy of a cookie. /
7609	enum class CookieSameSitePolicy {
7610	None = `181`,
7611	Lax = `182`,
7612	Strict = `183`,
7613	}; // enum class CookieSameSitePolicy
7614
7615	#if (defined(ENABLE_DARK_MODE_CSS) && ENABLE_DARK_MODE_CSS) \|\| (defined(HAVE_OS_DARK_MODE_SUPPORT) && HAVE_OS_DARK_MODE_SUPPORT)
7616	/ Page appearance name. /
7617	enum class Appearance {
7618	Light = `184`,
7619	Dark = `185`,
7620	}; // enum class Appearance
7621	#endif // (defined(ENABLE_DARK_MODE_CSS) && ENABLE_DARK_MODE_CSS) \|\| (defined(HAVE_OS_DARK_MODE_SUPPORT) && HAVE_OS_DARK_MODE_SUPPORT)
7622
7623	/ Information about the Frame on the page. /
7624	class Frame final : public JSON::ObjectBase {
7625	public:
7626	enum {
7627	NoFieldsSet = `0`,
7628	IdSet = `1` << `0`,
7629	LoaderIdSet = `1` << `1`,
7630	UrlSet = `1` << `2`,
7631	SecurityOriginSet = `1` << `3`,
7632	MimeTypeSet = `1` << `4`,
7633	AllFieldsSet = (IdSet \| LoaderIdSet \| UrlSet \| SecurityOriginSet \| MimeTypeSet)
7634	};
7635
7636	template<int STATE>
7637	class Builder {
7638	private:
7639	RefPtr<JSON::Object> m_result;
7640
7641	template<int STEP> Builder<STATE \| STEP>& castState()
7642	{
7643	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
7644	}
7645
7646	Builder(Ref</Frame/JSON::Object>&& object)
7647	: m_result (WTFMove(object))
7648	{
7649	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7650	}
7651	friend class Frame;
7652	public:
7653
7654	Builder<STATE \| IdSet>& setId(const String& in_id)
7655	{
7656	COMPILE_ASSERT(!(STATE & IdSet), property_id_already_set);
7657	m_result ->setString("id"_s, in_id);
7658	return castState<IdSet>();
7659	}
7660
7661	Builder<STATE \| LoaderIdSet>& setLoaderId(const String& in_loaderId)
7662	{
7663	COMPILE_ASSERT(!(STATE & LoaderIdSet), property_loaderId_already_set);
7664	m_result ->setString("loaderId"_s, in_loaderId);
7665	return castState<LoaderIdSet>();
7666	}
7667
7668	Builder<STATE \| UrlSet>& setUrl(const String& in_url)
7669	{
7670	COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
7671	m_result ->setString("url"_s, in_url);
7672	return castState<UrlSet>();
7673	}
7674
7675	Builder<STATE \| SecurityOriginSet>& setSecurityOrigin(const String& in_securityOrigin)
7676	{
7677	COMPILE_ASSERT(!(STATE & SecurityOriginSet), property_securityOrigin_already_set);
7678	m_result ->setString("securityOrigin"_s, in_securityOrigin);
7679	return castState<SecurityOriginSet>();
7680	}
7681
7682	Builder<STATE \| MimeTypeSet>& setMimeType(const String& in_mimeType)
7683	{
7684	COMPILE_ASSERT(!(STATE & MimeTypeSet), property_mimeType_already_set);
7685	m_result ->setString("mimeType"_s, in_mimeType);
7686	return castState<MimeTypeSet>();
7687	}
7688
7689	Ref<Frame> release()
7690	{
7691	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7692	COMPILE_ASSERT(sizeof(Frame) == sizeof(JSON::Object), cannot_cast);
7693
7694	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7695	auto result = WTFMove(*reinterpret_cast<Ref<Frame>*>(&jsonResult));
7696	return result;
7697	}
7698	};
7699
7700	/*
7701	* Synthetic constructor:
7702	* Ref<Frame> result = Frame::create()
7703	* .setId(...)
7704	* .setLoaderId(...)
7705	* .setUrl(...)
7706	* .setSecurityOrigin(...)
7707	* .setMimeType(...)
7708	* .release();
7709	*/
7710	static Builder<NoFieldsSet> create()
7711	{
7712	return Builder<NoFieldsSet>(JSON::Object::create());
7713	}
7714
7715	void setParentId(const String& in_opt_parentId)
7716	{
7717	JSON::ObjectBase::setString("parentId"_s, in_opt_parentId);
7718	}
7719
7720	void setName(const String& in_opt_name)
7721	{
7722	JSON::ObjectBase::setString("name"_s, in_opt_name);
7723	}
7724	};
7725
7726	class FrameResource final : public JSON::ObjectBase {
7727	public:
7728	enum {
7729	NoFieldsSet = `0`,
7730	UrlSet = `1` << `0`,
7731	TypeSet = `1` << `1`,
7732	MimeTypeSet = `1` << `2`,
7733	AllFieldsSet = (UrlSet \| TypeSet \| MimeTypeSet)
7734	};
7735
7736	template<int STATE>
7737	class Builder {
7738	private:
7739	RefPtr<JSON::Object> m_result;
7740
7741	template<int STEP> Builder<STATE \| STEP>& castState()
7742	{
7743	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
7744	}
7745
7746	Builder(Ref</FrameResource/JSON::Object>&& object)
7747	: m_result (WTFMove(object))
7748	{
7749	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7750	}
7751	friend class FrameResource;
7752	public:
7753
7754	Builder<STATE \| UrlSet>& setUrl(const String& in_url)
7755	{
7756	COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
7757	m_result ->setString("url"_s, in_url);
7758	return castState<UrlSet>();
7759	}
7760
7761	Builder<STATE \| TypeSet>& setType(Protocol::Page::ResourceType in_type)
7762	{
7763	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
7764	m_result ->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
7765	return castState<TypeSet>();
7766	}
7767
7768	Builder<STATE \| MimeTypeSet>& setMimeType(const String& in_mimeType)
7769	{
7770	COMPILE_ASSERT(!(STATE & MimeTypeSet), property_mimeType_already_set);
7771	m_result ->setString("mimeType"_s, in_mimeType);
7772	return castState<MimeTypeSet>();
7773	}
7774
7775	Ref<FrameResource> release()
7776	{
7777	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7778	COMPILE_ASSERT(sizeof(FrameResource) == sizeof(JSON::Object), cannot_cast);
7779
7780	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7781	auto result = WTFMove(*reinterpret_cast<Ref<FrameResource>*>(&jsonResult));
7782	return result;
7783	}
7784	};
7785
7786	/*
7787	* Synthetic constructor:
7788	* Ref<FrameResource> result = FrameResource::create()
7789	* .setUrl(...)
7790	* .setType(...)
7791	* .setMimeType(...)
7792	* .release();
7793	*/
7794	static Builder<NoFieldsSet> create()
7795	{
7796	return Builder<NoFieldsSet>(JSON::Object::create());
7797	}
7798
7799	void setFailed(bool in_opt_failed)
7800	{
7801	JSON::ObjectBase::setBoolean("failed"_s, in_opt_failed);
7802	}
7803
7804	void setCanceled(bool in_opt_canceled)
7805	{
7806	JSON::ObjectBase::setBoolean("canceled"_s, in_opt_canceled);
7807	}
7808
7809	void setSourceMapURL(const String& in_opt_sourceMapURL)
7810	{
7811	JSON::ObjectBase::setString("sourceMapURL"_s, in_opt_sourceMapURL);
7812	}
7813
7814	void setTargetId(const String& in_opt_targetId)
7815	{
7816	JSON::ObjectBase::setString("targetId"_s, in_opt_targetId);
7817	}
7818	};
7819
7820	/ Information about the Frame hierarchy along with their cached resources. /
7821	class FrameResourceTree final : public JSON::ObjectBase {
7822	public:
7823	enum {
7824	NoFieldsSet = `0`,
7825	FrameSet = `1` << `0`,
7826	ResourcesSet = `1` << `1`,
7827	AllFieldsSet = (FrameSet \| ResourcesSet)
7828	};
7829
7830	template<int STATE>
7831	class Builder {
7832	private:
7833	RefPtr<JSON::Object> m_result;
7834
7835	template<int STEP> Builder<STATE \| STEP>& castState()
7836	{
7837	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
7838	}
7839
7840	Builder(Ref</FrameResourceTree/JSON::Object>&& object)
7841	: m_result (WTFMove(object))
7842	{
7843	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7844	}
7845	friend class FrameResourceTree;
7846	public:
7847
7848	Builder<STATE \| FrameSet>& setFrame(Ref<Protocol::Page::Frame>&& in_frame)
7849	{
7850	COMPILE_ASSERT(!(STATE & FrameSet), property_frame_already_set);
7851	m_result ->setObject("frame"_s, WTFMove(in_frame));
7852	return castState<FrameSet>();
7853	}
7854
7855	Builder<STATE \| ResourcesSet>& setResources(Ref<JSON::ArrayOf<Protocol::Page::FrameResource>>&& in_resources)
7856	{
7857	COMPILE_ASSERT(!(STATE & ResourcesSet), property_resources_already_set);
7858	m_result ->setArray("resources"_s, WTFMove(in_resources));
7859	return castState<ResourcesSet>();
7860	}
7861
7862	Ref<FrameResourceTree> release()
7863	{
7864	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7865	COMPILE_ASSERT(sizeof(FrameResourceTree) == sizeof(JSON::Object), cannot_cast);
7866
7867	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7868	auto result = WTFMove(*reinterpret_cast<Ref<FrameResourceTree>*>(&jsonResult));
7869	return result;
7870	}
7871	};
7872
7873	/*
7874	* Synthetic constructor:
7875	* Ref<FrameResourceTree> result = FrameResourceTree::create()
7876	* .setFrame(...)
7877	* .setResources(...)
7878	* .release();
7879	*/
7880	static Builder<NoFieldsSet> create()
7881	{
7882	return Builder<NoFieldsSet>(JSON::Object::create());
7883	}
7884
7885	void setChildFrames(Ref<JSON::ArrayOf<Protocol::Page::FrameResourceTree>>&& in_opt_childFrames)
7886	{
7887	JSON::ObjectBase::setArray("childFrames"_s, WTFMove(in_opt_childFrames));
7888	}
7889	};
7890
7891	/ Search result for resource. /
7892	class SearchResult final : public JSON::ObjectBase {
7893	public:
7894	enum {
7895	NoFieldsSet = `0`,
7896	UrlSet = `1` << `0`,
7897	FrameIdSet = `1` << `1`,
7898	MatchesCountSet = `1` << `2`,
7899	AllFieldsSet = (UrlSet \| FrameIdSet \| MatchesCountSet)
7900	};
7901
7902	template<int STATE>
7903	class Builder {
7904	private:
7905	RefPtr<JSON::Object> m_result;
7906
7907	template<int STEP> Builder<STATE \| STEP>& castState()
7908	{
7909	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
7910	}
7911
7912	Builder(Ref</SearchResult/JSON::Object>&& object)
7913	: m_result (WTFMove(object))
7914	{
7915	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7916	}
7917	friend class SearchResult;
7918	public:
7919
7920	Builder<STATE \| UrlSet>& setUrl(const String& in_url)
7921	{
7922	COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
7923	m_result ->setString("url"_s, in_url);
7924	return castState<UrlSet>();
7925	}
7926
7927	Builder<STATE \| FrameIdSet>& setFrameId(const String& in_frameId)
7928	{
7929	COMPILE_ASSERT(!(STATE & FrameIdSet), property_frameId_already_set);
7930	m_result ->setString("frameId"_s, in_frameId);
7931	return castState<FrameIdSet>();
7932	}
7933
7934	Builder<STATE \| MatchesCountSet>& setMatchesCount(double in_matchesCount)
7935	{
7936	COMPILE_ASSERT(!(STATE & MatchesCountSet), property_matchesCount_already_set);
7937	m_result ->setDouble("matchesCount"_s, in_matchesCount);
7938	return castState<MatchesCountSet>();
7939	}
7940
7941	Ref<SearchResult> release()
7942	{
7943	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7944	COMPILE_ASSERT(sizeof(SearchResult) == sizeof(JSON::Object), cannot_cast);
7945
7946	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7947	auto result = WTFMove(*reinterpret_cast<Ref<SearchResult>*>(&jsonResult));
7948	return result;
7949	}
7950	};
7951
7952	/*
7953	* Synthetic constructor:
7954	* Ref<SearchResult> result = SearchResult::create()
7955	* .setUrl(...)
7956	* .setFrameId(...)
7957	* .setMatchesCount(...)
7958	* .release();
7959	*/
7960	static Builder<NoFieldsSet> create()
7961	{
7962	return Builder<NoFieldsSet>(JSON::Object::create());
7963	}
7964
7965	void setRequestId(const String& in_opt_requestId)
7966	{
7967	JSON::ObjectBase::setString("requestId"_s, in_opt_requestId);
7968	}
7969	};
7970
7971	/ Cookie object /
7972	class Cookie final : public JSON::Object {
7973	public:
7974	enum {
7975	NoFieldsSet = `0`,
7976	NameSet = `1` << `0`,
7977	ValueSet = `1` << `1`,
7978	DomainSet = `1` << `2`,
7979	PathSet = `1` << `3`,
7980	ExpiresSet = `1` << `4`,
7981	SessionSet = `1` << `5`,
7982	HttpOnlySet = `1` << `6`,
7983	SecureSet = `1` << `7`,
7984	SameSiteSet = `1` << `8`,
7985	AllFieldsSet = (NameSet \| ValueSet \| DomainSet \| PathSet \| ExpiresSet \| SessionSet \| HttpOnlySet \| SecureSet \| SameSiteSet)
7986	};
7987
7988	template<int STATE>
7989	class Builder {
7990	private:
7991	RefPtr<JSON::Object> m_result;
7992
7993	template<int STEP> Builder<STATE \| STEP>& castState()
7994	{
7995	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
7996	}
7997
7998	Builder(Ref</Cookie/JSON::Object>&& object)
7999	: m_result (WTFMove(object))
8000	{
8001	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8002	}
8003	friend class Cookie;
8004	public:
8005
8006	Builder<STATE \| NameSet>& setName(const String& in_name)
8007	{
8008	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
8009	m_result ->setString("name"_s, in_name);
8010	return castState<NameSet>();
8011	}
8012
8013	Builder<STATE \| ValueSet>& setValue(const String& in_value)
8014	{
8015	COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set);
8016	m_result ->setString("value"_s, in_value);
8017	return castState<ValueSet>();
8018	}
8019
8020	Builder<STATE \| DomainSet>& setDomain(const String& in_domain)
8021	{
8022	COMPILE_ASSERT(!(STATE & DomainSet), property_domain_already_set);
8023	m_result ->setString("domain"_s, in_domain);
8024	return castState<DomainSet>();
8025	}
8026
8027	Builder<STATE \| PathSet>& setPath(const String& in_path)
8028	{
8029	COMPILE_ASSERT(!(STATE & PathSet), property_path_already_set);
8030	m_result ->setString("path"_s, in_path);
8031	return castState<PathSet>();
8032	}
8033
8034	Builder<STATE \| ExpiresSet>& setExpires(double in_expires)
8035	{
8036	COMPILE_ASSERT(!(STATE & ExpiresSet), property_expires_already_set);
8037	m_result ->setDouble("expires"_s, in_expires);
8038	return castState<ExpiresSet>();
8039	}
8040
8041	Builder<STATE \| SessionSet>& setSession(bool in_session)
8042	{
8043	COMPILE_ASSERT(!(STATE & SessionSet), property_session_already_set);
8044	m_result ->setBoolean("session"_s, in_session);
8045	return castState<SessionSet>();
8046	}
8047
8048	Builder<STATE \| HttpOnlySet>& setHttpOnly(bool in_httpOnly)
8049	{
8050	COMPILE_ASSERT(!(STATE & HttpOnlySet), property_httpOnly_already_set);
8051	m_result ->setBoolean("httpOnly"_s, in_httpOnly);
8052	return castState<HttpOnlySet>();
8053	}
8054
8055	Builder<STATE \| SecureSet>& setSecure(bool in_secure)
8056	{
8057	COMPILE_ASSERT(!(STATE & SecureSet), property_secure_already_set);
8058	m_result ->setBoolean("secure"_s, in_secure);
8059	return castState<SecureSet>();
8060	}
8061
8062	Builder<STATE \| SameSiteSet>& setSameSite(Protocol::Page::CookieSameSitePolicy in_sameSite)
8063	{
8064	COMPILE_ASSERT(!(STATE & SameSiteSet), property_sameSite_already_set);
8065	m_result ->setString("sameSite"_s, Protocol::Helpers::getEnumConstantValue(in_sameSite));
8066	return castState<SameSiteSet>();
8067	}
8068
8069	Ref<Cookie> release()
8070	{
8071	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8072	COMPILE_ASSERT(sizeof(Cookie) == sizeof(JSON::Object), cannot_cast);
8073
8074	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8075	auto result = WTFMove(*reinterpret_cast<Ref<Cookie>*>(&jsonResult));
8076	return result;
8077	}
8078	};
8079
8080	/*
8081	* Synthetic constructor:
8082	* Ref<Cookie> result = Cookie::create()
8083	* .setName(...)
8084	* .setValue(...)
8085	* .setDomain(...)
8086	* .setPath(...)
8087	* .setExpires(...)
8088	* .setSession(...)
8089	* .setHttpOnly(...)
8090	* .setSecure(...)
8091	* .setSameSite(...)
8092	* .release();
8093	*/
8094	static Builder<NoFieldsSet> create()
8095	{
8096	return Builder<NoFieldsSet>(JSON::Object::create());
8097	}
8098
8099	// Property names for type generated as open.
8100	JS_EXPORT_PRIVATE static const ASCIILiteral nameKey;
8101	JS_EXPORT_PRIVATE static const ASCIILiteral valueKey;
8102	JS_EXPORT_PRIVATE static const ASCIILiteral domainKey;
8103	JS_EXPORT_PRIVATE static const ASCIILiteral pathKey;
8104	JS_EXPORT_PRIVATE static const ASCIILiteral expiresKey;
8105	JS_EXPORT_PRIVATE static const ASCIILiteral sessionKey;
8106	JS_EXPORT_PRIVATE static const ASCIILiteral httpOnlyKey;
8107	JS_EXPORT_PRIVATE static const ASCIILiteral secureKey;
8108	JS_EXPORT_PRIVATE static const ASCIILiteral sameSiteKey;
8109	};
8110
8111	} // Page
8112
8113	namespace Recording {
8114
8115	/ The type of the recording. /
8116	enum class Type {
8117	Canvas2D = `45`,
8118	CanvasBitmapRenderer = `186`,
8119	CanvasWebGL = `187`,
8120	CanvasWebGL2 = `188`,
8121	}; // enum class Type
8122
8123	enum class Initiator {
8124	Frontend = `189`,
8125	Console = `190`,
8126	AutoCapture = `191`,
8127	}; // enum class Initiator
8128
8129	/ Information about the initial state of the recorded object. /
8130	class InitialState final : public JSON::ObjectBase {
8131	public:
8132	enum {
8133	NoFieldsSet = `0`,
8134	AllFieldsSet = `0`
8135	};
8136
8137	template<int STATE>
8138	class Builder {
8139	private:
8140	RefPtr<JSON::Object> m_result;
8141
8142	template<int STEP> Builder<STATE \| STEP>& castState()
8143	{
8144	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
8145	}
8146
8147	Builder(Ref</InitialState/JSON::Object>&& object)
8148	: m_result (WTFMove(object))
8149	{
8150	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8151	}
8152	friend class InitialState;
8153	public:
8154
8155	Ref<InitialState> release()
8156	{
8157	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8158	COMPILE_ASSERT(sizeof(InitialState) == sizeof(JSON::Object), cannot_cast);
8159
8160	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8161	auto result = WTFMove(*reinterpret_cast<Ref<InitialState>*>(&jsonResult));
8162	return result;
8163	}
8164	};
8165
8166	/*
8167	* Synthetic constructor:
8168	* Ref<InitialState> result = InitialState::create()
8169	* .release();
8170	*/
8171	static Builder<NoFieldsSet> create()
8172	{
8173	return Builder<NoFieldsSet>(JSON::Object::create());
8174	}
8175
8176	void setAttributes(Ref<JSON::Object>&& in_opt_attributes)
8177	{
8178	JSON::ObjectBase::setObject("attributes"_s, WTFMove(in_opt_attributes));
8179	}
8180
8181	void setStates(Ref<JSON::ArrayOf<JSON::Object>>&& in_opt_states)
8182	{
8183	JSON::ObjectBase::setArray("states"_s, WTFMove(in_opt_states));
8184	}
8185
8186	void setParameters(Ref<JSON::ArrayOf<JSON::Value>>&& in_opt_parameters)
8187	{
8188	JSON::ObjectBase::setArray("parameters"_s, WTFMove(in_opt_parameters));
8189	}
8190
8191	void setContent(const String& in_opt_content)
8192	{
8193	JSON::ObjectBase::setString("content"_s, in_opt_content);
8194	}
8195	};
8196
8197	/ Container object for a single frame of the recording. /
8198	class Frame final : public JSON::ObjectBase {
8199	public:
8200	enum {
8201	NoFieldsSet = `0`,
8202	ActionsSet = `1` << `0`,
8203	AllFieldsSet = (ActionsSet)
8204	};
8205
8206	template<int STATE>
8207	class Builder {
8208	private:
8209	RefPtr<JSON::Object> m_result;
8210
8211	template<int STEP> Builder<STATE \| STEP>& castState()
8212	{
8213	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
8214	}
8215
8216	Builder(Ref</Frame/JSON::Object>&& object)
8217	: m_result (WTFMove(object))
8218	{
8219	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8220	}
8221	friend class Frame;
8222	public:
8223
8224	Builder<STATE \| ActionsSet>& setActions(Ref<JSON::ArrayOf<JSON::Value>>&& in_actions)
8225	{
8226	COMPILE_ASSERT(!(STATE & ActionsSet), property_actions_already_set);
8227	m_result ->setArray("actions"_s, WTFMove(in_actions));
8228	return castState<ActionsSet>();
8229	}
8230
8231	Ref<Frame> release()
8232	{
8233	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8234	COMPILE_ASSERT(sizeof(Frame) == sizeof(JSON::Object), cannot_cast);
8235
8236	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8237	auto result = WTFMove(*reinterpret_cast<Ref<Frame>*>(&jsonResult));
8238	return result;
8239	}
8240	};
8241
8242	/*
8243	* Synthetic constructor:
8244	* Ref<Frame> result = Frame::create()
8245	* .setActions(...)
8246	* .release();
8247	*/
8248	static Builder<NoFieldsSet> create()
8249	{
8250	return Builder<NoFieldsSet>(JSON::Object::create());
8251	}
8252
8253	void setDuration(double in_opt_duration)
8254	{
8255	JSON::ObjectBase::setDouble("duration"_s, in_opt_duration);
8256	}
8257
8258	void setIncomplete(bool in_opt_incomplete)
8259	{
8260	JSON::ObjectBase::setBoolean("incomplete"_s, in_opt_incomplete);
8261	}
8262	};
8263
8264	class Recording final : public JSON::ObjectBase {
8265	public:
8266	enum {
8267	NoFieldsSet = `0`,
8268	VersionSet = `1` << `0`,
8269	TypeSet = `1` << `1`,
8270	InitialStateSet = `1` << `2`,
8271	DataSet = `1` << `3`,
8272	AllFieldsSet = (VersionSet \| TypeSet \| InitialStateSet \| DataSet)
8273	};
8274
8275	template<int STATE>
8276	class Builder {
8277	private:
8278	RefPtr<JSON::Object> m_result;
8279
8280	template<int STEP> Builder<STATE \| STEP>& castState()
8281	{
8282	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
8283	}
8284
8285	Builder(Ref</Recording/JSON::Object>&& object)
8286	: m_result (WTFMove(object))
8287	{
8288	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8289	}
8290	friend class Recording;
8291	public:
8292
8293	Builder<STATE \| VersionSet>& setVersion(int in_version)
8294	{
8295	COMPILE_ASSERT(!(STATE & VersionSet), property_version_already_set);
8296	m_result ->setInteger("version"_s, in_version);
8297	return castState<VersionSet>();
8298	}
8299
8300	Builder<STATE \| TypeSet>& setType(Protocol::Recording::Type in_type)
8301	{
8302	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
8303	m_result ->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
8304	return castState<TypeSet>();
8305	}
8306
8307	Builder<STATE \| InitialStateSet>& setInitialState(Ref<Protocol::Recording::InitialState>&& in_initialState)
8308	{
8309	COMPILE_ASSERT(!(STATE & InitialStateSet), property_initialState_already_set);
8310	m_result ->setObject("initialState"_s, WTFMove(in_initialState));
8311	return castState<InitialStateSet>();
8312	}
8313
8314	Builder<STATE \| DataSet>& setData(Ref<JSON::ArrayOf<JSON::Value>>&& in_data)
8315	{
8316	COMPILE_ASSERT(!(STATE & DataSet), property_data_already_set);
8317	m_result ->setArray("data"_s, WTFMove(in_data));
8318	return castState<DataSet>();
8319	}
8320
8321	Ref<Recording> release()
8322	{
8323	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8324	COMPILE_ASSERT(sizeof(Recording) == sizeof(JSON::Object), cannot_cast);
8325
8326	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8327	auto result = WTFMove(*reinterpret_cast<Ref<Recording>*>(&jsonResult));
8328	return result;
8329	}
8330	};
8331
8332	/*
8333	* Synthetic constructor:
8334	* Ref<Recording> result = Recording::create()
8335	* .setVersion(...)
8336	* .setType(...)
8337	* .setInitialState(...)
8338	* .setData(...)
8339	* .release();
8340	*/
8341	static Builder<NoFieldsSet> create()
8342	{
8343	return Builder<NoFieldsSet>(JSON::Object::create());
8344	}
8345
8346	void setName(const String& in_opt_name)
8347	{
8348	JSON::ObjectBase::setString("name"_s, in_opt_name);
8349	}
8350	};
8351
8352	} // Recording
8353
8354	namespace Runtime {
8355
8356	/ Mirror object referencing original JavaScript object. /
8357	class RemoteObject final : public JSON::ObjectBase {
8358	public:
8359	// Named after property name 'type' while generating RemoteObject.
8360	enum class Type {
8361	Object = `192`,
8362	Function = `193`,
8363	Undefined = `194`,
8364	String = `133`,
8365	Number = `132`,
8366	Boolean = `195`,
8367	Symbol = `196`,
8368	Bigint = `197`,
8369	}; // enum class Type
8370
8371	// Named after property name 'subtype' while generating RemoteObject.
8372	enum class Subtype {
8373	Array = `134`,
8374	Null = `135`,
8375	Node = `198`,
8376	Regexp = `199`,
8377	Date = `107`,
8378	Error = `77`,
8379	Map = `200`,
8380	Set = `201`,
8381	Weakmap = `202`,
8382	Weakset = `203`,
8383	Iterator = `204`,
8384	Class = `205`,
8385	Proxy = `206`,
8386	}; // enum class Subtype
8387
8388	enum {
8389	NoFieldsSet = `0`,
8390	TypeSet = `1` << `0`,
8391	AllFieldsSet = (TypeSet)
8392	};
8393
8394	template<int STATE>
8395	class Builder {
8396	private:
8397	RefPtr<JSON::Object> m_result;
8398
8399	template<int STEP> Builder<STATE \| STEP>& castState()
8400	{
8401	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
8402	}
8403
8404	Builder(Ref</RemoteObject/JSON::Object>&& object)
8405	: m_result (WTFMove(object))
8406	{
8407	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8408	}
8409	friend class RemoteObject;
8410	public:
8411
8412	Builder<STATE \| TypeSet>& setType(Type in_type)
8413	{
8414	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
8415	m_result ->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
8416	return castState<TypeSet>();
8417	}
8418
8419	Ref<RemoteObject> release()
8420	{
8421	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8422	COMPILE_ASSERT(sizeof(RemoteObject) == sizeof(JSON::Object), cannot_cast);
8423
8424	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8425	auto result = WTFMove(*reinterpret_cast<Ref<RemoteObject>*>(&jsonResult));
8426	return result;
8427	}
8428	};
8429
8430	/*
8431	* Synthetic constructor:
8432	* Ref<RemoteObject> result = RemoteObject::create()
8433	* .setType(...)
8434	* .release();
8435	*/
8436	static Builder<NoFieldsSet> create()
8437	{
8438	return Builder<NoFieldsSet>(JSON::Object::create());
8439	}
8440
8441	void setSubtype(Subtype in_opt_subtype)
8442	{
8443	JSON::ObjectBase::setString("subtype"_s, Protocol::Helpers::getEnumConstantValue(in_opt_subtype));
8444	}
8445
8446	void setClassName(const String& in_opt_className)
8447	{
8448	JSON::ObjectBase::setString("className"_s, in_opt_className);
8449	}
8450
8451	void setValue(Ref<JSON::Value>&& in_opt_value)
8452	{
8453	JSON::ObjectBase::setValue("value"_s, WTFMove(in_opt_value));
8454	}
8455
8456	void setDescription(const String& in_opt_description)
8457	{
8458	JSON::ObjectBase::setString("description"_s, in_opt_description);
8459	}
8460
8461	void setObjectId(const String& in_opt_objectId)
8462	{
8463	JSON::ObjectBase::setString("objectId"_s, in_opt_objectId);
8464	}
8465
8466	void setSize(int in_opt_size)
8467	{
8468	JSON::ObjectBase::setInteger("size"_s, in_opt_size);
8469	}
8470
8471	void setClassPrototype(Ref<Protocol::Runtime::RemoteObject>&& in_opt_classPrototype)
8472	{
8473	JSON::ObjectBase::setObject("classPrototype"_s, WTFMove(in_opt_classPrototype));
8474	}
8475
8476	void setPreview(Ref<Protocol::Runtime::ObjectPreview>&& in_opt_preview)
8477	{
8478	JSON::ObjectBase::setObject("preview"_s, WTFMove(in_opt_preview));
8479	}
8480	};
8481
8482	/ Object containing abbreviated remote object value. /
8483	class ObjectPreview final : public JSON::ObjectBase {
8484	public:
8485	// Named after property name 'type' while generating ObjectPreview.
8486	enum class Type {
8487	Object = `192`,
8488	Function = `193`,
8489	Undefined = `194`,
8490	String = `133`,
8491	Number = `132`,
8492	Boolean = `195`,
8493	Symbol = `196`,
8494	Bigint = `197`,
8495	}; // enum class Type
8496
8497	// Named after property name 'subtype' while generating ObjectPreview.
8498	enum class Subtype {
8499	Array = `134`,
8500	Null = `135`,
8501	Node = `198`,
8502	Regexp = `199`,
8503	Date = `107`,
8504	Error = `77`,
8505	Map = `200`,
8506	Set = `201`,
8507	Weakmap = `202`,
8508	Weakset = `203`,
8509	Iterator = `204`,
8510	Class = `205`,
8511	Proxy = `206`,
8512	}; // enum class Subtype
8513
8514	enum {
8515	NoFieldsSet = `0`,
8516	TypeSet = `1` << `0`,
8517	LosslessSet = `1` << `1`,
8518	AllFieldsSet = (TypeSet \| LosslessSet)
8519	};
8520
8521	template<int STATE>
8522	class Builder {
8523	private:
8524	RefPtr<JSON::Object> m_result;
8525
8526	template<int STEP> Builder<STATE \| STEP>& castState()
8527	{
8528	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
8529	}
8530
8531	Builder(Ref</ObjectPreview/JSON::Object>&& object)
8532	: m_result (WTFMove(object))
8533	{
8534	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8535	}
8536	friend class ObjectPreview;
8537	public:
8538
8539	Builder<STATE \| TypeSet>& setType(Type in_type)
8540	{
8541	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
8542	m_result ->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
8543	return castState<TypeSet>();
8544	}
8545
8546	Builder<STATE \| LosslessSet>& setLossless(bool in_lossless)
8547	{
8548	COMPILE_ASSERT(!(STATE & LosslessSet), property_lossless_already_set);
8549	m_result ->setBoolean("lossless"_s, in_lossless);
8550	return castState<LosslessSet>();
8551	}
8552
8553	Ref<ObjectPreview> release()
8554	{
8555	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8556	COMPILE_ASSERT(sizeof(ObjectPreview) == sizeof(JSON::Object), cannot_cast);
8557
8558	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8559	auto result = WTFMove(*reinterpret_cast<Ref<ObjectPreview>*>(&jsonResult));
8560	return result;
8561	}
8562	};
8563
8564	/*
8565	* Synthetic constructor:
8566	* Ref<ObjectPreview> result = ObjectPreview::create()
8567	* .setType(...)
8568	* .setLossless(...)
8569	* .release();
8570	*/
8571	static Builder<NoFieldsSet> create()
8572	{
8573	return Builder<NoFieldsSet>(JSON::Object::create());
8574	}
8575
8576	void setSubtype(Subtype in_opt_subtype)
8577	{
8578	JSON::ObjectBase::setString("subtype"_s, Protocol::Helpers::getEnumConstantValue(in_opt_subtype));
8579	}
8580
8581	void setDescription(const String& in_opt_description)
8582	{
8583	JSON::ObjectBase::setString("description"_s, in_opt_description);
8584	}
8585
8586	void setOverflow(bool in_opt_overflow)
8587	{
8588	JSON::ObjectBase::setBoolean("overflow"_s, in_opt_overflow);
8589	}
8590
8591	void setProperties(Ref<JSON::ArrayOf<Protocol::Runtime::PropertyPreview>>&& in_opt_properties)
8592	{
8593	JSON::ObjectBase::setArray("properties"_s, WTFMove(in_opt_properties));
8594	}
8595
8596	void setEntries(Ref<JSON::ArrayOf<Protocol::Runtime::EntryPreview>>&& in_opt_entries)
8597	{
8598	JSON::ObjectBase::setArray("entries"_s, WTFMove(in_opt_entries));
8599	}
8600
8601	void setSize(int in_opt_size)
8602	{
8603	JSON::ObjectBase::setInteger("size"_s, in_opt_size);
8604	}
8605	};
8606
8607	class PropertyPreview final : public JSON::ObjectBase {
8608	public:
8609	// Named after property name 'type' while generating PropertyPreview.
8610	enum class Type {
8611	Object = `192`,
8612	Function = `193`,
8613	Undefined = `194`,
8614	String = `133`,
8615	Number = `132`,
8616	Boolean = `195`,
8617	Symbol = `196`,
8618	Bigint = `197`,
8619	Accessor = `207`,
8620	}; // enum class Type
8621
8622	// Named after property name 'subtype' while generating PropertyPreview.
8623	enum class Subtype {
8624	Array = `134`,
8625	Null = `135`,
8626	Node = `198`,
8627	Regexp = `199`,
8628	Date = `107`,
8629	Error = `77`,
8630	Map = `200`,
8631	Set = `201`,
8632	Weakmap = `202`,
8633	Weakset = `203`,
8634	Iterator = `204`,
8635	Class = `205`,
8636	Proxy = `206`,
8637	}; // enum class Subtype
8638
8639	enum {
8640	NoFieldsSet = `0`,
8641	NameSet = `1` << `0`,
8642	TypeSet = `1` << `1`,
8643	AllFieldsSet = (NameSet \| TypeSet)
8644	};
8645
8646	template<int STATE>
8647	class Builder {
8648	private:
8649	RefPtr<JSON::Object> m_result;
8650
8651	template<int STEP> Builder<STATE \| STEP>& castState()
8652	{
8653	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
8654	}
8655
8656	Builder(Ref</PropertyPreview/JSON::Object>&& object)
8657	: m_result (WTFMove(object))
8658	{
8659	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8660	}
8661	friend class PropertyPreview;
8662	public:
8663
8664	Builder<STATE \| NameSet>& setName(const String& in_name)
8665	{
8666	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
8667	m_result ->setString("name"_s, in_name);
8668	return castState<NameSet>();
8669	}
8670
8671	Builder<STATE \| TypeSet>& setType(Type in_type)
8672	{
8673	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
8674	m_result ->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
8675	return castState<TypeSet>();
8676	}
8677
8678	Ref<PropertyPreview> release()
8679	{
8680	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8681	COMPILE_ASSERT(sizeof(PropertyPreview) == sizeof(JSON::Object), cannot_cast);
8682
8683	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8684	auto result = WTFMove(*reinterpret_cast<Ref<PropertyPreview>*>(&jsonResult));
8685	return result;
8686	}
8687	};
8688
8689	/*
8690	* Synthetic constructor:
8691	* Ref<PropertyPreview> result = PropertyPreview::create()
8692	* .setName(...)
8693	* .setType(...)
8694	* .release();
8695	*/
8696	static Builder<NoFieldsSet> create()
8697	{
8698	return Builder<NoFieldsSet>(JSON::Object::create());
8699	}
8700
8701	void setSubtype(Subtype in_opt_subtype)
8702	{
8703	JSON::ObjectBase::setString("subtype"_s, Protocol::Helpers::getEnumConstantValue(in_opt_subtype));
8704	}
8705
8706	void setValue(const String& in_opt_value)
8707	{
8708	JSON::ObjectBase::setString("value"_s, in_opt_value);
8709	}
8710
8711	void setValuePreview(Ref<Protocol::Runtime::ObjectPreview>&& in_opt_valuePreview)
8712	{
8713	JSON::ObjectBase::setObject("valuePreview"_s, WTFMove(in_opt_valuePreview));
8714	}
8715
8716	void setInternal(bool in_opt_internal)
8717	{
8718	JSON::ObjectBase::setBoolean("internal"_s, in_opt_internal);
8719	}
8720	};
8721
8722	class EntryPreview final : public JSON::ObjectBase {
8723	public:
8724	enum {
8725	NoFieldsSet = `0`,
8726	ValueSet = `1` << `0`,
8727	AllFieldsSet = (ValueSet)
8728	};
8729
8730	template<int STATE>
8731	class Builder {
8732	private:
8733	RefPtr<JSON::Object> m_result;
8734
8735	template<int STEP> Builder<STATE \| STEP>& castState()
8736	{
8737	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
8738	}
8739
8740	Builder(Ref</EntryPreview/JSON::Object>&& object)
8741	: m_result (WTFMove(object))
8742	{
8743	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8744	}
8745	friend class EntryPreview;
8746	public:
8747
8748	Builder<STATE \| ValueSet>& setValue(Ref<Protocol::Runtime::ObjectPreview>&& in_value)
8749	{
8750	COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set);
8751	m_result ->setObject("value"_s, WTFMove(in_value));
8752	return castState<ValueSet>();
8753	}
8754
8755	Ref<EntryPreview> release()
8756	{
8757	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8758	COMPILE_ASSERT(sizeof(EntryPreview) == sizeof(JSON::Object), cannot_cast);
8759
8760	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8761	auto result = WTFMove(*reinterpret_cast<Ref<EntryPreview>*>(&jsonResult));
8762	return result;
8763	}
8764	};
8765
8766	/*
8767	* Synthetic constructor:
8768	* Ref<EntryPreview> result = EntryPreview::create()
8769	* .setValue(...)
8770	* .release();
8771	*/
8772	static Builder<NoFieldsSet> create()
8773	{
8774	return Builder<NoFieldsSet>(JSON::Object::create());
8775	}
8776
8777	void setKey(Ref<Protocol::Runtime::ObjectPreview>&& in_opt_key)
8778	{
8779	JSON::ObjectBase::setObject("key"_s, WTFMove(in_opt_key));
8780	}
8781	};
8782
8783	class CollectionEntry final : public JSON::ObjectBase {
8784	public:
8785	enum {
8786	NoFieldsSet = `0`,
8787	ValueSet = `1` << `0`,
8788	AllFieldsSet = (ValueSet)
8789	};
8790
8791	template<int STATE>
8792	class Builder {
8793	private:
8794	RefPtr<JSON::Object> m_result;
8795
8796	template<int STEP> Builder<STATE \| STEP>& castState()
8797	{
8798	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
8799	}
8800
8801	Builder(Ref</CollectionEntry/JSON::Object>&& object)
8802	: m_result (WTFMove(object))
8803	{
8804	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8805	}
8806	friend class CollectionEntry;
8807	public:
8808
8809	Builder<STATE \| ValueSet>& setValue(Ref<Protocol::Runtime::RemoteObject>&& in_value)
8810	{
8811	COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set);
8812	m_result ->setObject("value"_s, WTFMove(in_value));
8813	return castState<ValueSet>();
8814	}
8815
8816	Ref<CollectionEntry> release()
8817	{
8818	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8819	COMPILE_ASSERT(sizeof(CollectionEntry) == sizeof(JSON::Object), cannot_cast);
8820
8821	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8822	auto result = WTFMove(*reinterpret_cast<Ref<CollectionEntry>*>(&jsonResult));
8823	return result;
8824	}
8825	};
8826
8827	/*
8828	* Synthetic constructor:
8829	* Ref<CollectionEntry> result = CollectionEntry::create()
8830	* .setValue(...)
8831	* .release();
8832	*/
8833	static Builder<NoFieldsSet> create()
8834	{
8835	return Builder<NoFieldsSet>(JSON::Object::create());
8836	}
8837
8838	void setKey(Ref<Protocol::Runtime::RemoteObject>&& in_opt_key)
8839	{
8840	JSON::ObjectBase::setObject("key"_s, WTFMove(in_opt_key));
8841	}
8842	};
8843
8844	/ Object property descriptor. /
8845	class PropertyDescriptor final : public JSON::ObjectBase {
8846	public:
8847	enum {
8848	NoFieldsSet = `0`,
8849	NameSet = `1` << `0`,
8850	AllFieldsSet = (NameSet)
8851	};
8852
8853	template<int STATE>
8854	class Builder {
8855	private:
8856	RefPtr<JSON::Object> m_result;
8857
8858	template<int STEP> Builder<STATE \| STEP>& castState()
8859	{
8860	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
8861	}
8862
8863	Builder(Ref</PropertyDescriptor/JSON::Object>&& object)
8864	: m_result (WTFMove(object))
8865	{
8866	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8867	}
8868	friend class PropertyDescriptor;
8869	public:
8870
8871	Builder<STATE \| NameSet>& setName(const String& in_name)
8872	{
8873	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
8874	m_result ->setString("name"_s, in_name);
8875	return castState<NameSet>();
8876	}
8877
8878	Ref<PropertyDescriptor> release()
8879	{
8880	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8881	COMPILE_ASSERT(sizeof(PropertyDescriptor) == sizeof(JSON::Object), cannot_cast);
8882
8883	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8884	auto result = WTFMove(*reinterpret_cast<Ref<PropertyDescriptor>*>(&jsonResult));
8885	return result;
8886	}
8887	};
8888
8889	/*
8890	* Synthetic constructor:
8891	* Ref<PropertyDescriptor> result = PropertyDescriptor::create()
8892	* .setName(...)
8893	* .release();
8894	*/
8895	static Builder<NoFieldsSet> create()
8896	{
8897	return Builder<NoFieldsSet>(JSON::Object::create());
8898	}
8899
8900	void setValue(Ref<Protocol::Runtime::RemoteObject>&& in_opt_value)
8901	{
8902	JSON::ObjectBase::setObject("value"_s, WTFMove(in_opt_value));
8903	}
8904
8905	void setWritable(bool in_opt_writable)
8906	{
8907	JSON::ObjectBase::setBoolean("writable"_s, in_opt_writable);
8908	}
8909
8910	void setGet(Ref<Protocol::Runtime::RemoteObject>&& in_opt_get)
8911	{
8912	JSON::ObjectBase::setObject("get"_s, WTFMove(in_opt_get));
8913	}
8914
8915	void setSet(Ref<Protocol::Runtime::RemoteObject>&& in_opt_set)
8916	{
8917	JSON::ObjectBase::setObject("set"_s, WTFMove(in_opt_set));
8918	}
8919
8920	void setWasThrown(bool in_opt_wasThrown)
8921	{
8922	JSON::ObjectBase::setBoolean("wasThrown"_s, in_opt_wasThrown);
8923	}
8924
8925	void setConfigurable(bool in_opt_configurable)
8926	{
8927	JSON::ObjectBase::setBoolean("configurable"_s, in_opt_configurable);
8928	}
8929
8930	void setEnumerable(bool in_opt_enumerable)
8931	{
8932	JSON::ObjectBase::setBoolean("enumerable"_s, in_opt_enumerable);
8933	}
8934
8935	void setIsOwn(bool in_opt_isOwn)
8936	{
8937	JSON::ObjectBase::setBoolean("isOwn"_s, in_opt_isOwn);
8938	}
8939
8940	void setSymbol(Ref<Protocol::Runtime::RemoteObject>&& in_opt_symbol)
8941	{
8942	JSON::ObjectBase::setObject("symbol"_s, WTFMove(in_opt_symbol));
8943	}
8944
8945	void setNativeGetter(bool in_opt_nativeGetter)
8946	{
8947	JSON::ObjectBase::setBoolean("nativeGetter"_s, in_opt_nativeGetter);
8948	}
8949	};
8950
8951	/ Object internal property descriptor. This property isn't normally visible in JavaScript code. /
8952	class InternalPropertyDescriptor final : public JSON::ObjectBase {
8953	public:
8954	enum {
8955	NoFieldsSet = `0`,
8956	NameSet = `1` << `0`,
8957	AllFieldsSet = (NameSet)
8958	};
8959
8960	template<int STATE>
8961	class Builder {
8962	private:
8963	RefPtr<JSON::Object> m_result;
8964
8965	template<int STEP> Builder<STATE \| STEP>& castState()
8966	{
8967	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
8968	}
8969
8970	Builder(Ref</InternalPropertyDescriptor/JSON::Object>&& object)
8971	: m_result (WTFMove(object))
8972	{
8973	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8974	}
8975	friend class InternalPropertyDescriptor;
8976	public:
8977
8978	Builder<STATE \| NameSet>& setName(const String& in_name)
8979	{
8980	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
8981	m_result ->setString("name"_s, in_name);
8982	return castState<NameSet>();
8983	}
8984
8985	Ref<InternalPropertyDescriptor> release()
8986	{
8987	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8988	COMPILE_ASSERT(sizeof(InternalPropertyDescriptor) == sizeof(JSON::Object), cannot_cast);
8989
8990	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8991	auto result = WTFMove(*reinterpret_cast<Ref<InternalPropertyDescriptor>*>(&jsonResult));
8992	return result;
8993	}
8994	};
8995
8996	/*
8997	* Synthetic constructor:
8998	* Ref<InternalPropertyDescriptor> result = InternalPropertyDescriptor::create()
8999	* .setName(...)
9000	* .release();
9001	*/
9002	static Builder<NoFieldsSet> create()
9003	{
9004	return Builder<NoFieldsSet>(JSON::Object::create());
9005	}
9006
9007	void setValue(Ref<Protocol::Runtime::RemoteObject>&& in_opt_value)
9008	{
9009	JSON::ObjectBase::setObject("value"_s, WTFMove(in_opt_value));
9010	}
9011	};
9012
9013	/ Represents function call argument. Either remote object id <code>objectId</code> or primitive <code>value</code> or neither of (for undefined) them should be specified. /
9014	class CallArgument final : public JSON::Object {
9015	public:
9016	enum {
9017	NoFieldsSet = `0`,
9018	AllFieldsSet = `0`
9019	};
9020
9021	template<int STATE>
9022	class Builder {
9023	private:
9024	RefPtr<JSON::Object> m_result;
9025
9026	template<int STEP> Builder<STATE \| STEP>& castState()
9027	{
9028	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
9029	}
9030
9031	Builder(Ref</CallArgument/JSON::Object>&& object)
9032	: m_result (WTFMove(object))
9033	{
9034	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9035	}
9036	friend class CallArgument;
9037	public:
9038
9039	Ref<CallArgument> release()
9040	{
9041	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9042	COMPILE_ASSERT(sizeof(CallArgument) == sizeof(JSON::Object), cannot_cast);
9043
9044	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9045	auto result = WTFMove(*reinterpret_cast<Ref<CallArgument>*>(&jsonResult));
9046	return result;
9047	}
9048	};
9049
9050	/*
9051	* Synthetic constructor:
9052	* Ref<CallArgument> result = CallArgument::create()
9053	* .release();
9054	*/
9055	static Builder<NoFieldsSet> create()
9056	{
9057	return Builder<NoFieldsSet>(JSON::Object::create());
9058	}
9059
9060	void setValue(Ref<JSON::Value>&& in_opt_value)
9061	{
9062	JSON::ObjectBase::setValue("value"_s, WTFMove(in_opt_value));
9063	}
9064
9065	void setObjectId(const String& in_opt_objectId)
9066	{
9067	JSON::ObjectBase::setString("objectId"_s, in_opt_objectId);
9068	}
9069
9070	// Property names for type generated as open.
9071	JS_EXPORT_PRIVATE static const ASCIILiteral objectIdKey;
9072	};
9073
9074	/ Type of the execution context. /
9075	enum class ExecutionContextType {
9076	Normal = `5`,
9077	User = `16`,
9078	Internal = `208`,
9079	}; // enum class ExecutionContextType
9080
9081	/ Description of an isolated world. /
9082	class ExecutionContextDescription final : public JSON::ObjectBase {
9083	public:
9084	enum {
9085	NoFieldsSet = `0`,
9086	IdSet = `1` << `0`,
9087	TypeSet = `1` << `1`,
9088	NameSet = `1` << `2`,
9089	FrameIdSet = `1` << `3`,
9090	AllFieldsSet = (IdSet \| TypeSet \| NameSet \| FrameIdSet)
9091	};
9092
9093	template<int STATE>
9094	class Builder {
9095	private:
9096	RefPtr<JSON::Object> m_result;
9097
9098	template<int STEP> Builder<STATE \| STEP>& castState()
9099	{
9100	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
9101	}
9102
9103	Builder(Ref</ExecutionContextDescription/JSON::Object>&& object)
9104	: m_result (WTFMove(object))
9105	{
9106	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9107	}
9108	friend class ExecutionContextDescription;
9109	public:
9110
9111	Builder<STATE \| IdSet>& setId(int in_id)
9112	{
9113	COMPILE_ASSERT(!(STATE & IdSet), property_id_already_set);
9114	m_result ->setInteger("id"_s, in_id);
9115	return castState<IdSet>();
9116	}
9117
9118	Builder<STATE \| TypeSet>& setType(Protocol::Runtime::ExecutionContextType in_type)
9119	{
9120	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
9121	m_result ->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
9122	return castState<TypeSet>();
9123	}
9124
9125	Builder<STATE \| NameSet>& setName(const String& in_name)
9126	{
9127	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
9128	m_result ->setString("name"_s, in_name);
9129	return castState<NameSet>();
9130	}
9131
9132	Builder<STATE \| FrameIdSet>& setFrameId(const String& in_frameId)
9133	{
9134	COMPILE_ASSERT(!(STATE & FrameIdSet), property_frameId_already_set);
9135	m_result ->setString("frameId"_s, in_frameId);
9136	return castState<FrameIdSet>();
9137	}
9138
9139	Ref<ExecutionContextDescription> release()
9140	{
9141	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9142	COMPILE_ASSERT(sizeof(ExecutionContextDescription) == sizeof(JSON::Object), cannot_cast);
9143
9144	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9145	auto result = WTFMove(*reinterpret_cast<Ref<ExecutionContextDescription>*>(&jsonResult));
9146	return result;
9147	}
9148	};
9149
9150	/*
9151	* Synthetic constructor:
9152	* Ref<ExecutionContextDescription> result = ExecutionContextDescription::create()
9153	* .setId(...)
9154	* .setType(...)
9155	* .setName(...)
9156	* .setFrameId(...)
9157	* .release();
9158	*/
9159	static Builder<NoFieldsSet> create()
9160	{
9161	return Builder<NoFieldsSet>(JSON::Object::create());
9162	}
9163	};
9164
9165	/* Syntax error type: "none" for no error, "irrecoverable" for unrecoverable errors, "unterminated-literal" for when there is an unterminated literal, "recoverable" for when the expression is unfinished but valid so far. */
9166	enum class SyntaxErrorType {
9167	None = `9`,
9168	Irrecoverable = `209`,
9169	UnterminatedLiteral = `210`,
9170	Recoverable = `211`,
9171	}; // enum class SyntaxErrorType
9172
9173	/ Range of an error in source code. /
9174	class ErrorRange final : public JSON::ObjectBase {
9175	public:
9176	enum {
9177	NoFieldsSet = `0`,
9178	StartOffsetSet = `1` << `0`,
9179	EndOffsetSet = `1` << `1`,
9180	AllFieldsSet = (StartOffsetSet \| EndOffsetSet)
9181	};
9182
9183	template<int STATE>
9184	class Builder {
9185	private:
9186	RefPtr<JSON::Object> m_result;
9187
9188	template<int STEP> Builder<STATE \| STEP>& castState()
9189	{
9190	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
9191	}
9192
9193	Builder(Ref</ErrorRange/JSON::Object>&& object)
9194	: m_result (WTFMove(object))
9195	{
9196	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9197	}
9198	friend class ErrorRange;
9199	public:
9200
9201	Builder<STATE \| StartOffsetSet>& setStartOffset(int in_startOffset)
9202	{
9203	COMPILE_ASSERT(!(STATE & StartOffsetSet), property_startOffset_already_set);
9204	m_result ->setInteger("startOffset"_s, in_startOffset);
9205	return castState<StartOffsetSet>();
9206	}
9207
9208	Builder<STATE \| EndOffsetSet>& setEndOffset(int in_endOffset)
9209	{
9210	COMPILE_ASSERT(!(STATE & EndOffsetSet), property_endOffset_already_set);
9211	m_result ->setInteger("endOffset"_s, in_endOffset);
9212	return castState<EndOffsetSet>();
9213	}
9214
9215	Ref<ErrorRange> release()
9216	{
9217	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9218	COMPILE_ASSERT(sizeof(ErrorRange) == sizeof(JSON::Object), cannot_cast);
9219
9220	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9221	auto result = WTFMove(*reinterpret_cast<Ref<ErrorRange>*>(&jsonResult));
9222	return result;
9223	}
9224	};
9225
9226	/*
9227	* Synthetic constructor:
9228	* Ref<ErrorRange> result = ErrorRange::create()
9229	* .setStartOffset(...)
9230	* .setEndOffset(...)
9231	* .release();
9232	*/
9233	static Builder<NoFieldsSet> create()
9234	{
9235	return Builder<NoFieldsSet>(JSON::Object::create());
9236	}
9237	};
9238
9239	class StructureDescription final : public JSON::ObjectBase {
9240	public:
9241	enum {
9242	NoFieldsSet = `0`,
9243	AllFieldsSet = `0`
9244	};
9245
9246	template<int STATE>
9247	class Builder {
9248	private:
9249	RefPtr<JSON::Object> m_result;
9250
9251	template<int STEP> Builder<STATE \| STEP>& castState()
9252	{
9253	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
9254	}
9255
9256	Builder(Ref</StructureDescription/JSON::Object>&& object)
9257	: m_result (WTFMove(object))
9258	{
9259	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9260	}
9261	friend class StructureDescription;
9262	public:
9263
9264	Ref<StructureDescription> release()
9265	{
9266	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9267	COMPILE_ASSERT(sizeof(StructureDescription) == sizeof(JSON::Object), cannot_cast);
9268
9269	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9270	auto result = WTFMove(*reinterpret_cast<Ref<StructureDescription>*>(&jsonResult));
9271	return result;
9272	}
9273	};
9274
9275	/*
9276	* Synthetic constructor:
9277	* Ref<StructureDescription> result = StructureDescription::create()
9278	* .release();
9279	*/
9280	static Builder<NoFieldsSet> create()
9281	{
9282	return Builder<NoFieldsSet>(JSON::Object::create());
9283	}
9284
9285	void setFields(Ref<JSON::ArrayOf<String>>&& in_opt_fields)
9286	{
9287	JSON::ObjectBase::setArray("fields"_s, WTFMove(in_opt_fields));
9288	}
9289
9290	void setOptionalFields(Ref<JSON::ArrayOf<String>>&& in_opt_optionalFields)
9291	{
9292	JSON::ObjectBase::setArray("optionalFields"_s, WTFMove(in_opt_optionalFields));
9293	}
9294
9295	void setConstructorName(const String& in_opt_constructorName)
9296	{
9297	JSON::ObjectBase::setString("constructorName"_s, in_opt_constructorName);
9298	}
9299
9300	void setPrototypeStructure(Ref<Protocol::Runtime::StructureDescription>&& in_opt_prototypeStructure)
9301	{
9302	JSON::ObjectBase::setObject("prototypeStructure"_s, WTFMove(in_opt_prototypeStructure));
9303	}
9304
9305	void setIsImprecise(bool in_opt_isImprecise)
9306	{
9307	JSON::ObjectBase::setBoolean("isImprecise"_s, in_opt_isImprecise);
9308	}
9309	};
9310
9311	class TypeSet final : public JSON::ObjectBase {
9312	public:
9313	enum {
9314	NoFieldsSet = `0`,
9315	IsFunctionSet = `1` << `0`,
9316	IsUndefinedSet = `1` << `1`,
9317	IsNullSet = `1` << `2`,
9318	IsBooleanSet = `1` << `3`,
9319	IsIntegerSet = `1` << `4`,
9320	IsNumberSet = `1` << `5`,
9321	IsStringSet = `1` << `6`,
9322	IsObjectSet = `1` << `7`,
9323	IsSymbolSet = `1` << `8`,
9324	IsBigIntSet = `1` << `9`,
9325	AllFieldsSet = (IsFunctionSet \| IsUndefinedSet \| IsNullSet \| IsBooleanSet \| IsIntegerSet \| IsNumberSet \| IsStringSet \| IsObjectSet \| IsSymbolSet \| IsBigIntSet)
9326	};
9327
9328	template<int STATE>
9329	class Builder {
9330	private:
9331	RefPtr<JSON::Object> m_result;
9332
9333	template<int STEP> Builder<STATE \| STEP>& castState()
9334	{
9335	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
9336	}
9337
9338	Builder(Ref</TypeSet/JSON::Object>&& object)
9339	: m_result (WTFMove(object))
9340	{
9341	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9342	}
9343	friend class TypeSet;
9344	public:
9345
9346	Builder<STATE \| IsFunctionSet>& setIsFunction(bool in_isFunction)
9347	{
9348	COMPILE_ASSERT(!(STATE & IsFunctionSet), property_isFunction_already_set);
9349	m_result ->setBoolean("isFunction"_s, in_isFunction);
9350	return castState<IsFunctionSet>();
9351	}
9352
9353	Builder<STATE \| IsUndefinedSet>& setIsUndefined(bool in_isUndefined)
9354	{
9355	COMPILE_ASSERT(!(STATE & IsUndefinedSet), property_isUndefined_already_set);
9356	m_result ->setBoolean("isUndefined"_s, in_isUndefined);
9357	return castState<IsUndefinedSet>();
9358	}
9359
9360	Builder<STATE \| IsNullSet>& setIsNull(bool in_isNull)
9361	{
9362	COMPILE_ASSERT(!(STATE & IsNullSet), property_isNull_already_set);
9363	m_result ->setBoolean("isNull"_s, in_isNull);
9364	return castState<IsNullSet>();
9365	}
9366
9367	Builder<STATE \| IsBooleanSet>& setIsBoolean(bool in_isBoolean)
9368	{
9369	COMPILE_ASSERT(!(STATE & IsBooleanSet), property_isBoolean_already_set);
9370	m_result ->setBoolean("isBoolean"_s, in_isBoolean);
9371	return castState<IsBooleanSet>();
9372	}
9373
9374	Builder<STATE \| IsIntegerSet>& setIsInteger(bool in_isInteger)
9375	{
9376	COMPILE_ASSERT(!(STATE & IsIntegerSet), property_isInteger_already_set);
9377	m_result ->setBoolean("isInteger"_s, in_isInteger);
9378	return castState<IsIntegerSet>();
9379	}
9380
9381	Builder<STATE \| IsNumberSet>& setIsNumber(bool in_isNumber)
9382	{
9383	COMPILE_ASSERT(!(STATE & IsNumberSet), property_isNumber_already_set);
9384	m_result ->setBoolean("isNumber"_s, in_isNumber);
9385	return castState<IsNumberSet>();
9386	}
9387
9388	Builder<STATE \| IsStringSet>& setIsString(bool in_isString)
9389	{
9390	COMPILE_ASSERT(!(STATE & IsStringSet), property_isString_already_set);
9391	m_result ->setBoolean("isString"_s, in_isString);
9392	return castState<IsStringSet>();
9393	}
9394
9395	Builder<STATE \| IsObjectSet>& setIsObject(bool in_isObject)
9396	{
9397	COMPILE_ASSERT(!(STATE & IsObjectSet), property_isObject_already_set);
9398	m_result ->setBoolean("isObject"_s, in_isObject);
9399	return castState<IsObjectSet>();
9400	}
9401
9402	Builder<STATE \| IsSymbolSet>& setIsSymbol(bool in_isSymbol)
9403	{
9404	COMPILE_ASSERT(!(STATE & IsSymbolSet), property_isSymbol_already_set);
9405	m_result ->setBoolean("isSymbol"_s, in_isSymbol);
9406	return castState<IsSymbolSet>();
9407	}
9408
9409	Builder<STATE \| IsBigIntSet>& setIsBigInt(bool in_isBigInt)
9410	{
9411	COMPILE_ASSERT(!(STATE & IsBigIntSet), property_isBigInt_already_set);
9412	m_result ->setBoolean("isBigInt"_s, in_isBigInt);
9413	return castState<IsBigIntSet>();
9414	}
9415
9416	Ref<TypeSet> release()
9417	{
9418	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9419	COMPILE_ASSERT(sizeof(TypeSet) == sizeof(JSON::Object), cannot_cast);
9420
9421	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9422	auto result = WTFMove(*reinterpret_cast<Ref<TypeSet>*>(&jsonResult));
9423	return result;
9424	}
9425	};
9426
9427	/*
9428	* Synthetic constructor:
9429	* Ref<TypeSet> result = TypeSet::create()
9430	* .setIsFunction(...)
9431	* .setIsUndefined(...)
9432	* .setIsNull(...)
9433	* .setIsBoolean(...)
9434	* .setIsInteger(...)
9435	* .setIsNumber(...)
9436	* .setIsString(...)
9437	* .setIsObject(...)
9438	* .setIsSymbol(...)
9439	* .setIsBigInt(...)
9440	* .release();
9441	*/
9442	static Builder<NoFieldsSet> create()
9443	{
9444	return Builder<NoFieldsSet>(JSON::Object::create());
9445	}
9446	};
9447
9448	/ Container for type information that has been gathered. /
9449	class TypeDescription final : public JSON::ObjectBase {
9450	public:
9451	enum {
9452	NoFieldsSet = `0`,
9453	IsValidSet = `1` << `0`,
9454	AllFieldsSet = (IsValidSet)
9455	};
9456
9457	template<int STATE>
9458	class Builder {
9459	private:
9460	RefPtr<JSON::Object> m_result;
9461
9462	template<int STEP> Builder<STATE \| STEP>& castState()
9463	{
9464	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
9465	}
9466
9467	Builder(Ref</TypeDescription/JSON::Object>&& object)
9468	: m_result (WTFMove(object))
9469	{
9470	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9471	}
9472	friend class TypeDescription;
9473	public:
9474
9475	Builder<STATE \| IsValidSet>& setIsValid(bool in_isValid)
9476	{
9477	COMPILE_ASSERT(!(STATE & IsValidSet), property_isValid_already_set);
9478	m_result ->setBoolean("isValid"_s, in_isValid);
9479	return castState<IsValidSet>();
9480	}
9481
9482	Ref<TypeDescription> release()
9483	{
9484	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9485	COMPILE_ASSERT(sizeof(TypeDescription) == sizeof(JSON::Object), cannot_cast);
9486
9487	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9488	auto result = WTFMove(*reinterpret_cast<Ref<TypeDescription>*>(&jsonResult));
9489	return result;
9490	}
9491	};
9492
9493	/*
9494	* Synthetic constructor:
9495	* Ref<TypeDescription> result = TypeDescription::create()
9496	* .setIsValid(...)
9497	* .release();
9498	*/
9499	static Builder<NoFieldsSet> create()
9500	{
9501	return Builder<NoFieldsSet>(JSON::Object::create());
9502	}
9503
9504	void setLeastCommonAncestor(const String& in_opt_leastCommonAncestor)
9505	{
9506	JSON::ObjectBase::setString("leastCommonAncestor"_s, in_opt_leastCommonAncestor);
9507	}
9508
9509	void setTypeSet(Ref<Protocol::Runtime::TypeSet>&& in_opt_typeSet)
9510	{
9511	JSON::ObjectBase::setObject("typeSet"_s, WTFMove(in_opt_typeSet));
9512	}
9513
9514	void setStructures(Ref<JSON::ArrayOf<Protocol::Runtime::StructureDescription>>&& in_opt_structures)
9515	{
9516	JSON::ObjectBase::setArray("structures"_s, WTFMove(in_opt_structures));
9517	}
9518
9519	void setIsTruncated(bool in_opt_isTruncated)
9520	{
9521	JSON::ObjectBase::setBoolean("isTruncated"_s, in_opt_isTruncated);
9522	}
9523	};
9524
9525	/ Describes the location of an expression we want type information for. /
9526	class TypeLocation final : public JSON::Object {
9527	public:
9528	enum {
9529	NoFieldsSet = `0`,
9530	TypeInformationDescriptorSet = `1` << `0`,
9531	SourceIDSet = `1` << `1`,
9532	DivotSet = `1` << `2`,
9533	AllFieldsSet = (TypeInformationDescriptorSet \| SourceIDSet \| DivotSet)
9534	};
9535
9536	template<int STATE>
9537	class Builder {
9538	private:
9539	RefPtr<JSON::Object> m_result;
9540
9541	template<int STEP> Builder<STATE \| STEP>& castState()
9542	{
9543	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
9544	}
9545
9546	Builder(Ref</TypeLocation/JSON::Object>&& object)
9547	: m_result (WTFMove(object))
9548	{
9549	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9550	}
9551	friend class TypeLocation;
9552	public:
9553
9554	Builder<STATE \| TypeInformationDescriptorSet>& setTypeInformationDescriptor(int in_typeInformationDescriptor)
9555	{
9556	COMPILE_ASSERT(!(STATE & TypeInformationDescriptorSet), property_typeInformationDescriptor_already_set);
9557	m_result ->setInteger("typeInformationDescriptor"_s, in_typeInformationDescriptor);
9558	return castState<TypeInformationDescriptorSet>();
9559	}
9560
9561	Builder<STATE \| SourceIDSet>& setSourceID(const String& in_sourceID)
9562	{
9563	COMPILE_ASSERT(!(STATE & SourceIDSet), property_sourceID_already_set);
9564	m_result ->setString("sourceID"_s, in_sourceID);
9565	return castState<SourceIDSet>();
9566	}
9567
9568	Builder<STATE \| DivotSet>& setDivot(int in_divot)
9569	{
9570	COMPILE_ASSERT(!(STATE & DivotSet), property_divot_already_set);
9571	m_result ->setInteger("divot"_s, in_divot);
9572	return castState<DivotSet>();
9573	}
9574
9575	Ref<TypeLocation> release()
9576	{
9577	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9578	COMPILE_ASSERT(sizeof(TypeLocation) == sizeof(JSON::Object), cannot_cast);
9579
9580	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9581	auto result = WTFMove(*reinterpret_cast<Ref<TypeLocation>*>(&jsonResult));
9582	return result;
9583	}
9584	};
9585
9586	/*
9587	* Synthetic constructor:
9588	* Ref<TypeLocation> result = TypeLocation::create()
9589	* .setTypeInformationDescriptor(...)
9590	* .setSourceID(...)
9591	* .setDivot(...)
9592	* .release();
9593	*/
9594	static Builder<NoFieldsSet> create()
9595	{
9596	return Builder<NoFieldsSet>(JSON::Object::create());
9597	}
9598
9599	// Property names for type generated as open.
9600	JS_EXPORT_PRIVATE static const ASCIILiteral typeInformationDescriptorKey;
9601	JS_EXPORT_PRIVATE static const ASCIILiteral sourceIDKey;
9602	JS_EXPORT_PRIVATE static const ASCIILiteral divotKey;
9603	};
9604
9605	/* From Wikipedia: a basic block is a portion of the code within a program with only one entry point and only one exit point. This type gives the location of a basic block and if that basic block has executed. */
9606	class BasicBlock final : public JSON::ObjectBase {
9607	public:
9608	enum {
9609	NoFieldsSet = `0`,
9610	StartOffsetSet = `1` << `0`,
9611	EndOffsetSet = `1` << `1`,
9612	HasExecutedSet = `1` << `2`,
9613	ExecutionCountSet = `1` << `3`,
9614	AllFieldsSet = (StartOffsetSet \| EndOffsetSet \| HasExecutedSet \| ExecutionCountSet)
9615	};
9616
9617	template<int STATE>
9618	class Builder {
9619	private:
9620	RefPtr<JSON::Object> m_result;
9621
9622	template<int STEP> Builder<STATE \| STEP>& castState()
9623	{
9624	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
9625	}
9626
9627	Builder(Ref</BasicBlock/JSON::Object>&& object)
9628	: m_result (WTFMove(object))
9629	{
9630	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9631	}
9632	friend class BasicBlock;
9633	public:
9634
9635	Builder<STATE \| StartOffsetSet>& setStartOffset(int in_startOffset)
9636	{
9637	COMPILE_ASSERT(!(STATE & StartOffsetSet), property_startOffset_already_set);
9638	m_result ->setInteger("startOffset"_s, in_startOffset);
9639	return castState<StartOffsetSet>();
9640	}
9641
9642	Builder<STATE \| EndOffsetSet>& setEndOffset(int in_endOffset)
9643	{
9644	COMPILE_ASSERT(!(STATE & EndOffsetSet), property_endOffset_already_set);
9645	m_result ->setInteger("endOffset"_s, in_endOffset);
9646	return castState<EndOffsetSet>();
9647	}
9648
9649	Builder<STATE \| HasExecutedSet>& setHasExecuted(bool in_hasExecuted)
9650	{
9651	COMPILE_ASSERT(!(STATE & HasExecutedSet), property_hasExecuted_already_set);
9652	m_result ->setBoolean("hasExecuted"_s, in_hasExecuted);
9653	return castState<HasExecutedSet>();
9654	}
9655
9656	Builder<STATE \| ExecutionCountSet>& setExecutionCount(int in_executionCount)
9657	{
9658	COMPILE_ASSERT(!(STATE & ExecutionCountSet), property_executionCount_already_set);
9659	m_result ->setInteger("executionCount"_s, in_executionCount);
9660	return castState<ExecutionCountSet>();
9661	}
9662
9663	Ref<BasicBlock> release()
9664	{
9665	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9666	COMPILE_ASSERT(sizeof(BasicBlock) == sizeof(JSON::Object), cannot_cast);
9667
9668	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9669	auto result = WTFMove(*reinterpret_cast<Ref<BasicBlock>*>(&jsonResult));
9670	return result;
9671	}
9672	};
9673
9674	/*
9675	* Synthetic constructor:
9676	* Ref<BasicBlock> result = BasicBlock::create()
9677	* .setStartOffset(...)
9678	* .setEndOffset(...)
9679	* .setHasExecuted(...)
9680	* .setExecutionCount(...)
9681	* .release();
9682	*/
9683	static Builder<NoFieldsSet> create()
9684	{
9685	return Builder<NoFieldsSet>(JSON::Object::create());
9686	}
9687	};
9688
9689	} // Runtime
9690
9691	namespace ScriptProfiler {
9692
9693	enum class EventType {
9694	API = `212`,
9695	Microtask = `213`,
9696	Other = `157`,
9697	}; // enum class EventType
9698
9699	class Event final : public JSON::ObjectBase {
9700	public:
9701	enum {
9702	NoFieldsSet = `0`,
9703	StartTimeSet = `1` << `0`,
9704	EndTimeSet = `1` << `1`,
9705	TypeSet = `1` << `2`,
9706	AllFieldsSet = (StartTimeSet \| EndTimeSet \| TypeSet)
9707	};
9708
9709	template<int STATE>
9710	class Builder {
9711	private:
9712	RefPtr<JSON::Object> m_result;
9713
9714	template<int STEP> Builder<STATE \| STEP>& castState()
9715	{
9716	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
9717	}
9718
9719	Builder(Ref</Event/JSON::Object>&& object)
9720	: m_result (WTFMove(object))
9721	{
9722	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9723	}
9724	friend class Event;
9725	public:
9726
9727	Builder<STATE \| StartTimeSet>& setStartTime(double in_startTime)
9728	{
9729	COMPILE_ASSERT(!(STATE & StartTimeSet), property_startTime_already_set);
9730	m_result ->setDouble("startTime"_s, in_startTime);
9731	return castState<StartTimeSet>();
9732	}
9733
9734	Builder<STATE \| EndTimeSet>& setEndTime(double in_endTime)
9735	{
9736	COMPILE_ASSERT(!(STATE & EndTimeSet), property_endTime_already_set);
9737	m_result ->setDouble("endTime"_s, in_endTime);
9738	return castState<EndTimeSet>();
9739	}
9740
9741	Builder<STATE \| TypeSet>& setType(Protocol::ScriptProfiler::EventType in_type)
9742	{
9743	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
9744	m_result ->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
9745	return castState<TypeSet>();
9746	}
9747
9748	Ref<Event> release()
9749	{
9750	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9751	COMPILE_ASSERT(sizeof(Event) == sizeof(JSON::Object), cannot_cast);
9752
9753	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9754	auto result = WTFMove(*reinterpret_cast<Ref<Event>*>(&jsonResult));
9755	return result;
9756	}
9757	};
9758
9759	/*
9760	* Synthetic constructor:
9761	* Ref<Event> result = Event::create()
9762	* .setStartTime(...)
9763	* .setEndTime(...)
9764	* .setType(...)
9765	* .release();
9766	*/
9767	static Builder<NoFieldsSet> create()
9768	{
9769	return Builder<NoFieldsSet>(JSON::Object::create());
9770	}
9771	};
9772
9773	class ExpressionLocation final : public JSON::ObjectBase {
9774	public:
9775	enum {
9776	NoFieldsSet = `0`,
9777	LineSet = `1` << `0`,
9778	ColumnSet = `1` << `1`,
9779	AllFieldsSet = (LineSet \| ColumnSet)
9780	};
9781
9782	template<int STATE>
9783	class Builder {
9784	private:
9785	RefPtr<JSON::Object> m_result;
9786
9787	template<int STEP> Builder<STATE \| STEP>& castState()
9788	{
9789	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
9790	}
9791
9792	Builder(Ref</ExpressionLocation/JSON::Object>&& object)
9793	: m_result (WTFMove(object))
9794	{
9795	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9796	}
9797	friend class ExpressionLocation;
9798	public:
9799
9800	Builder<STATE \| LineSet>& setLine(int in_line)
9801	{
9802	COMPILE_ASSERT(!(STATE & LineSet), property_line_already_set);
9803	m_result ->setInteger("line"_s, in_line);
9804	return castState<LineSet>();
9805	}
9806
9807	Builder<STATE \| ColumnSet>& setColumn(int in_column)
9808	{
9809	COMPILE_ASSERT(!(STATE & ColumnSet), property_column_already_set);
9810	m_result ->setInteger("column"_s, in_column);
9811	return castState<ColumnSet>();
9812	}
9813
9814	Ref<ExpressionLocation> release()
9815	{
9816	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9817	COMPILE_ASSERT(sizeof(ExpressionLocation) == sizeof(JSON::Object), cannot_cast);
9818
9819	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9820	auto result = WTFMove(*reinterpret_cast<Ref<ExpressionLocation>*>(&jsonResult));
9821	return result;
9822	}
9823	};
9824
9825	/*
9826	* Synthetic constructor:
9827	* Ref<ExpressionLocation> result = ExpressionLocation::create()
9828	* .setLine(...)
9829	* .setColumn(...)
9830	* .release();
9831	*/
9832	static Builder<NoFieldsSet> create()
9833	{
9834	return Builder<NoFieldsSet>(JSON::Object::create());
9835	}
9836	};
9837
9838	class StackFrame final : public JSON::ObjectBase {
9839	public:
9840	enum {
9841	NoFieldsSet = `0`,
9842	SourceIDSet = `1` << `0`,
9843	NameSet = `1` << `1`,
9844	LineSet = `1` << `2`,
9845	ColumnSet = `1` << `3`,
9846	UrlSet = `1` << `4`,
9847	AllFieldsSet = (SourceIDSet \| NameSet \| LineSet \| ColumnSet \| UrlSet)
9848	};
9849
9850	template<int STATE>
9851	class Builder {
9852	private:
9853	RefPtr<JSON::Object> m_result;
9854
9855	template<int STEP> Builder<STATE \| STEP>& castState()
9856	{
9857	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
9858	}
9859
9860	Builder(Ref</StackFrame/JSON::Object>&& object)
9861	: m_result (WTFMove(object))
9862	{
9863	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9864	}
9865	friend class StackFrame;
9866	public:
9867
9868	Builder<STATE \| SourceIDSet>& setSourceID(const String& in_sourceID)
9869	{
9870	COMPILE_ASSERT(!(STATE & SourceIDSet), property_sourceID_already_set);
9871	m_result ->setString("sourceID"_s, in_sourceID);
9872	return castState<SourceIDSet>();
9873	}
9874
9875	Builder<STATE \| NameSet>& setName(const String& in_name)
9876	{
9877	COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
9878	m_result ->setString("name"_s, in_name);
9879	return castState<NameSet>();
9880	}
9881
9882	Builder<STATE \| LineSet>& setLine(int in_line)
9883	{
9884	COMPILE_ASSERT(!(STATE & LineSet), property_line_already_set);
9885	m_result ->setInteger("line"_s, in_line);
9886	return castState<LineSet>();
9887	}
9888
9889	Builder<STATE \| ColumnSet>& setColumn(int in_column)
9890	{
9891	COMPILE_ASSERT(!(STATE & ColumnSet), property_column_already_set);
9892	m_result ->setInteger("column"_s, in_column);
9893	return castState<ColumnSet>();
9894	}
9895
9896	Builder<STATE \| UrlSet>& setUrl(const String& in_url)
9897	{
9898	COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
9899	m_result ->setString("url"_s, in_url);
9900	return castState<UrlSet>();
9901	}
9902
9903	Ref<StackFrame> release()
9904	{
9905	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9906	COMPILE_ASSERT(sizeof(StackFrame) == sizeof(JSON::Object), cannot_cast);
9907
9908	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9909	auto result = WTFMove(*reinterpret_cast<Ref<StackFrame>*>(&jsonResult));
9910	return result;
9911	}
9912	};
9913
9914	/*
9915	* Synthetic constructor:
9916	* Ref<StackFrame> result = StackFrame::create()
9917	* .setSourceID(...)
9918	* .setName(...)
9919	* .setLine(...)
9920	* .setColumn(...)
9921	* .setUrl(...)
9922	* .release();
9923	*/
9924	static Builder<NoFieldsSet> create()
9925	{
9926	return Builder<NoFieldsSet>(JSON::Object::create());
9927	}
9928
9929	void setExpressionLocation(Ref<Protocol::ScriptProfiler::ExpressionLocation>&& in_opt_expressionLocation)
9930	{
9931	JSON::ObjectBase::setObject("expressionLocation"_s, WTFMove(in_opt_expressionLocation));
9932	}
9933	};
9934
9935	class StackTrace final : public JSON::ObjectBase {
9936	public:
9937	enum {
9938	NoFieldsSet = `0`,
9939	TimestampSet = `1` << `0`,
9940	StackFramesSet = `1` << `1`,
9941	AllFieldsSet = (TimestampSet \| StackFramesSet)
9942	};
9943
9944	template<int STATE>
9945	class Builder {
9946	private:
9947	RefPtr<JSON::Object> m_result;
9948
9949	template<int STEP> Builder<STATE \| STEP>& castState()
9950	{
9951	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
9952	}
9953
9954	Builder(Ref</StackTrace/JSON::Object>&& object)
9955	: m_result (WTFMove(object))
9956	{
9957	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9958	}
9959	friend class StackTrace;
9960	public:
9961
9962	Builder<STATE \| TimestampSet>& setTimestamp(double in_timestamp)
9963	{
9964	COMPILE_ASSERT(!(STATE & TimestampSet), property_timestamp_already_set);
9965	m_result ->setDouble("timestamp"_s, in_timestamp);
9966	return castState<TimestampSet>();
9967	}
9968
9969	Builder<STATE \| StackFramesSet>& setStackFrames(Ref<JSON::ArrayOf<Protocol::ScriptProfiler::StackFrame>>&& in_stackFrames)
9970	{
9971	COMPILE_ASSERT(!(STATE & StackFramesSet), property_stackFrames_already_set);
9972	m_result ->setArray("stackFrames"_s, WTFMove(in_stackFrames));
9973	return castState<StackFramesSet>();
9974	}
9975
9976	Ref<StackTrace> release()
9977	{
9978	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9979	COMPILE_ASSERT(sizeof(StackTrace) == sizeof(JSON::Object), cannot_cast);
9980
9981	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9982	auto result = WTFMove(*reinterpret_cast<Ref<StackTrace>*>(&jsonResult));
9983	return result;
9984	}
9985	};
9986
9987	/*
9988	* Synthetic constructor:
9989	* Ref<StackTrace> result = StackTrace::create()
9990	* .setTimestamp(...)
9991	* .setStackFrames(...)
9992	* .release();
9993	*/
9994	static Builder<NoFieldsSet> create()
9995	{
9996	return Builder<NoFieldsSet>(JSON::Object::create());
9997	}
9998	};
9999
10000	class Samples final : public JSON::ObjectBase {
10001	public:
10002	enum {
10003	NoFieldsSet = `0`,
10004	StackTracesSet = `1` << `0`,
10005	AllFieldsSet = (StackTracesSet)
10006	};
10007
10008	template<int STATE>
10009	class Builder {
10010	private:
10011	RefPtr<JSON::Object> m_result;
10012
10013	template<int STEP> Builder<STATE \| STEP>& castState()
10014	{
10015	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
10016	}
10017
10018	Builder(Ref</Samples/JSON::Object>&& object)
10019	: m_result (WTFMove(object))
10020	{
10021	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
10022	}
10023	friend class Samples;
10024	public:
10025
10026	Builder<STATE \| StackTracesSet>& setStackTraces(Ref<JSON::ArrayOf<Protocol::ScriptProfiler::StackTrace>>&& in_stackTraces)
10027	{
10028	COMPILE_ASSERT(!(STATE & StackTracesSet), property_stackTraces_already_set);
10029	m_result ->setArray("stackTraces"_s, WTFMove(in_stackTraces));
10030	return castState<StackTracesSet>();
10031	}
10032
10033	Ref<Samples> release()
10034	{
10035	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
10036	COMPILE_ASSERT(sizeof(Samples) == sizeof(JSON::Object), cannot_cast);
10037
10038	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
10039	auto result = WTFMove(*reinterpret_cast<Ref<Samples>*>(&jsonResult));
10040	return result;
10041	}
10042	};
10043
10044	/*
10045	* Synthetic constructor:
10046	* Ref<Samples> result = Samples::create()
10047	* .setStackTraces(...)
10048	* .release();
10049	*/
10050	static Builder<NoFieldsSet> create()
10051	{
10052	return Builder<NoFieldsSet>(JSON::Object::create());
10053	}
10054	};
10055
10056	} // ScriptProfiler
10057
10058	namespace Security {
10059
10060	/ Information about a SSL connection to display in the frontend. /
10061	class Connection final : public JSON::ObjectBase {
10062	public:
10063	enum {
10064	NoFieldsSet = `0`,
10065	AllFieldsSet = `0`
10066	};
10067
10068	template<int STATE>
10069	class Builder {
10070	private:
10071	RefPtr<JSON::Object> m_result;
10072
10073	template<int STEP> Builder<STATE \| STEP>& castState()
10074	{
10075	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
10076	}
10077
10078	Builder(Ref</Connection/JSON::Object>&& object)
10079	: m_result (WTFMove(object))
10080	{
10081	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
10082	}
10083	friend class Connection;
10084	public:
10085
10086	Ref<Connection> release()
10087	{
10088	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
10089	COMPILE_ASSERT(sizeof(Connection) == sizeof(JSON::Object), cannot_cast);
10090
10091	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
10092	auto result = WTFMove(*reinterpret_cast<Ref<Connection>*>(&jsonResult));
10093	return result;
10094	}
10095	};
10096
10097	/*
10098	* Synthetic constructor:
10099	* Ref<Connection> result = Connection::create()
10100	* .release();
10101	*/
10102	static Builder<NoFieldsSet> create()
10103	{
10104	return Builder<NoFieldsSet>(JSON::Object::create());
10105	}
10106
10107	void setProtocol(const String& in_opt_protocol)
10108	{
10109	JSON::ObjectBase::setString("protocol"_s, in_opt_protocol);
10110	}
10111
10112	void setCipher(const String& in_opt_cipher)
10113	{
10114	JSON::ObjectBase::setString("cipher"_s, in_opt_cipher);
10115	}
10116	};
10117
10118	/ Information about a SSL certificate to display in the frontend. /
10119	class Certificate final : public JSON::ObjectBase {
10120	public:
10121	enum {
10122	NoFieldsSet = `0`,
10123	AllFieldsSet = `0`
10124	};
10125
10126	template<int STATE>
10127	class Builder {
10128	private:
10129	RefPtr<JSON::Object> m_result;
10130
10131	template<int STEP> Builder<STATE \| STEP>& castState()
10132	{
10133	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
10134	}
10135
10136	Builder(Ref</Certificate/JSON::Object>&& object)
10137	: m_result (WTFMove(object))
10138	{
10139	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
10140	}
10141	friend class Certificate;
10142	public:
10143
10144	Ref<Certificate> release()
10145	{
10146	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
10147	COMPILE_ASSERT(sizeof(Certificate) == sizeof(JSON::Object), cannot_cast);
10148
10149	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
10150	auto result = WTFMove(*reinterpret_cast<Ref<Certificate>*>(&jsonResult));
10151	return result;
10152	}
10153	};
10154
10155	/*
10156	* Synthetic constructor:
10157	* Ref<Certificate> result = Certificate::create()
10158	* .release();
10159	*/
10160	static Builder<NoFieldsSet> create()
10161	{
10162	return Builder<NoFieldsSet>(JSON::Object::create());
10163	}
10164
10165	void setSubject(const String& in_opt_subject)
10166	{
10167	JSON::ObjectBase::setString("subject"_s, in_opt_subject);
10168	}
10169
10170	void setValidFrom(double in_opt_validFrom)
10171	{
10172	JSON::ObjectBase::setDouble("validFrom"_s, in_opt_validFrom);
10173	}
10174
10175	void setValidUntil(double in_opt_validUntil)
10176	{
10177	JSON::ObjectBase::setDouble("validUntil"_s, in_opt_validUntil);
10178	}
10179
10180	void setDnsNames(Ref<JSON::ArrayOf<String>>&& in_opt_dnsNames)
10181	{
10182	JSON::ObjectBase::setArray("dnsNames"_s, WTFMove(in_opt_dnsNames));
10183	}
10184
10185	void setIpAddresses(Ref<JSON::ArrayOf<String>>&& in_opt_ipAddresses)
10186	{
10187	JSON::ObjectBase::setArray("ipAddresses"_s, WTFMove(in_opt_ipAddresses));
10188	}
10189	};
10190
10191	/ Security information for a given Network.Response. /
10192	class Security final : public JSON::ObjectBase {
10193	public:
10194	enum {
10195	NoFieldsSet = `0`,
10196	AllFieldsSet = `0`
10197	};
10198
10199	template<int STATE>
10200	class Builder {
10201	private:
10202	RefPtr<JSON::Object> m_result;
10203
10204	template<int STEP> Builder<STATE \| STEP>& castState()
10205	{
10206	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
10207	}
10208
10209	Builder(Ref</Security/JSON::Object>&& object)
10210	: m_result (WTFMove(object))
10211	{
10212	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
10213	}
10214	friend class Security;
10215	public:
10216
10217	Ref<Security> release()
10218	{
10219	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
10220	COMPILE_ASSERT(sizeof(Security) == sizeof(JSON::Object), cannot_cast);
10221
10222	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
10223	auto result = WTFMove(*reinterpret_cast<Ref<Security>*>(&jsonResult));
10224	return result;
10225	}
10226	};
10227
10228	/*
10229	* Synthetic constructor:
10230	* Ref<Security> result = Security::create()
10231	* .release();
10232	*/
10233	static Builder<NoFieldsSet> create()
10234	{
10235	return Builder<NoFieldsSet>(JSON::Object::create());
10236	}
10237
10238	void setConnection(Ref<Protocol::Security::Connection>&& in_opt_connection)
10239	{
10240	JSON::ObjectBase::setObject("connection"_s, WTFMove(in_opt_connection));
10241	}
10242
10243	void setCertificate(Ref<Protocol::Security::Certificate>&& in_opt_certificate)
10244	{
10245	JSON::ObjectBase::setObject("certificate"_s, WTFMove(in_opt_certificate));
10246	}
10247	};
10248
10249	} // Security
10250
10251	#if defined(ENABLE_SERVICE_WORKER) && ENABLE_SERVICE_WORKER
10252	namespace ServiceWorker {
10253
10254	/ ServiceWorker metadata and initial state. /
10255	class Configuration final : public JSON::ObjectBase {
10256	public:
10257	enum {
10258	NoFieldsSet = `0`,
10259	TargetIdSet = `1` << `0`,
10260	SecurityOriginSet = `1` << `1`,
10261	UrlSet = `1` << `2`,
10262	ContentSet = `1` << `3`,
10263	AllFieldsSet = (TargetIdSet \| SecurityOriginSet \| UrlSet \| ContentSet)
10264	};
10265
10266	template<int STATE>
10267	class Builder {
10268	private:
10269	RefPtr<JSON::Object> m_result;
10270
10271	template<int STEP> Builder<STATE \| STEP>& castState()
10272	{
10273	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
10274	}
10275
10276	Builder(Ref</Configuration/JSON::Object>&& object)
10277	: m_result (WTFMove(object))
10278	{
10279	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
10280	}
10281	friend class Configuration;
10282	public:
10283
10284	Builder<STATE \| TargetIdSet>& setTargetId(const String& in_targetId)
10285	{
10286	COMPILE_ASSERT(!(STATE & TargetIdSet), property_targetId_already_set);
10287	m_result ->setString("targetId"_s, in_targetId);
10288	return castState<TargetIdSet>();
10289	}
10290
10291	Builder<STATE \| SecurityOriginSet>& setSecurityOrigin(const String& in_securityOrigin)
10292	{
10293	COMPILE_ASSERT(!(STATE & SecurityOriginSet), property_securityOrigin_already_set);
10294	m_result ->setString("securityOrigin"_s, in_securityOrigin);
10295	return castState<SecurityOriginSet>();
10296	}
10297
10298	Builder<STATE \| UrlSet>& setUrl(const String& in_url)
10299	{
10300	COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
10301	m_result ->setString("url"_s, in_url);
10302	return castState<UrlSet>();
10303	}
10304
10305	Builder<STATE \| ContentSet>& setContent(const String& in_content)
10306	{
10307	COMPILE_ASSERT(!(STATE & ContentSet), property_content_already_set);
10308	m_result ->setString("content"_s, in_content);
10309	return castState<ContentSet>();
10310	}
10311
10312	Ref<Configuration> release()
10313	{
10314	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
10315	COMPILE_ASSERT(sizeof(Configuration) == sizeof(JSON::Object), cannot_cast);
10316
10317	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
10318	auto result = WTFMove(*reinterpret_cast<Ref<Configuration>*>(&jsonResult));
10319	return result;
10320	}
10321	};
10322
10323	/*
10324	* Synthetic constructor:
10325	* Ref<Configuration> result = Configuration::create()
10326	* .setTargetId(...)
10327	* .setSecurityOrigin(...)
10328	* .setUrl(...)
10329	* .setContent(...)
10330	* .release();
10331	*/
10332	static Builder<NoFieldsSet> create()
10333	{
10334	return Builder<NoFieldsSet>(JSON::Object::create());
10335	}
10336	};
10337
10338	} // ServiceWorker
10339	#endif // defined(ENABLE_SERVICE_WORKER) && ENABLE_SERVICE_WORKER
10340
10341	namespace Target {
10342
10343	/ Description of a target. /
10344	class TargetInfo final : public JSON::ObjectBase {
10345	public:
10346	// Named after property name 'type' while generating TargetInfo.
10347	enum class Type {
10348	Page = `104`,
10349	ServiceWorker = `142`,
10350	Worker = `214`,
10351	}; // enum class Type
10352
10353	enum {
10354	NoFieldsSet = `0`,
10355	TargetIdSet = `1` << `0`,
10356	TypeSet = `1` << `1`,
10357	AllFieldsSet = (TargetIdSet \| TypeSet)
10358	};
10359
10360	template<int STATE>
10361	class Builder {
10362	private:
10363	RefPtr<JSON::Object> m_result;
10364
10365	template<int STEP> Builder<STATE \| STEP>& castState()
10366	{
10367	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
10368	}
10369
10370	Builder(Ref</TargetInfo/JSON::Object>&& object)
10371	: m_result (WTFMove(object))
10372	{
10373	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
10374	}
10375	friend class TargetInfo;
10376	public:
10377
10378	Builder<STATE \| TargetIdSet>& setTargetId(const String& in_targetId)
10379	{
10380	COMPILE_ASSERT(!(STATE & TargetIdSet), property_targetId_already_set);
10381	m_result ->setString("targetId"_s, in_targetId);
10382	return castState<TargetIdSet>();
10383	}
10384
10385	Builder<STATE \| TypeSet>& setType(Type in_type)
10386	{
10387	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
10388	m_result ->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
10389	return castState<TypeSet>();
10390	}
10391
10392	Ref<TargetInfo> release()
10393	{
10394	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
10395	COMPILE_ASSERT(sizeof(TargetInfo) == sizeof(JSON::Object), cannot_cast);
10396
10397	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
10398	auto result = WTFMove(*reinterpret_cast<Ref<TargetInfo>*>(&jsonResult));
10399	return result;
10400	}
10401	};
10402
10403	/*
10404	* Synthetic constructor:
10405	* Ref<TargetInfo> result = TargetInfo::create()
10406	* .setTargetId(...)
10407	* .setType(...)
10408	* .release();
10409	*/
10410	static Builder<NoFieldsSet> create()
10411	{
10412	return Builder<NoFieldsSet>(JSON::Object::create());
10413	}
10414
10415	void setIsProvisional(bool in_opt_isProvisional)
10416	{
10417	JSON::ObjectBase::setBoolean("isProvisional"_s, in_opt_isProvisional);
10418	}
10419
10420	void setIsPaused(bool in_opt_isPaused)
10421	{
10422	JSON::ObjectBase::setBoolean("isPaused"_s, in_opt_isPaused);
10423	}
10424	};
10425
10426	} // Target
10427
10428	namespace Timeline {
10429
10430	/ Timeline record type. /
10431	enum class EventType {
10432	EventDispatch = `215`,
10433	ScheduleStyleRecalculation = `216`,
10434	RecalculateStyles = `217`,
10435	InvalidateLayout = `218`,
10436	Layout = `219`,
10437	Paint = `220`,
10438	Composite = `221`,
10439	RenderingFrame = `222`,
10440	TimerInstall = `223`,
10441	TimerRemove = `224`,
10442	TimerFire = `225`,
10443	EvaluateScript = `226`,
10444	TimeStamp = `227`,
10445	Time = `228`,
10446	TimeEnd = `229`,
10447	FunctionCall = `230`,
10448	ProbeSample = `231`,
10449	ConsoleProfile = `232`,
10450	RequestAnimationFrame = `233`,
10451	CancelAnimationFrame = `234`,
10452	FireAnimationFrame = `235`,
10453	ObserverCallback = `236`,
10454	}; // enum class EventType
10455
10456	/ Instrument types. /
10457	enum class Instrument {
10458	ScriptProfiler = `237`,
10459	Timeline = `238`,
10460	CPU = `239`,
10461	Memory = `240`,
10462	Heap = `241`,
10463	Animation = `242`,
10464	}; // enum class Instrument
10465
10466	/ Timeline record contains information about the recorded activity. /
10467	class TimelineEvent final : public JSON::Object {
10468	public:
10469	enum {
10470	NoFieldsSet = `0`,
10471	TypeSet = `1` << `0`,
10472	DataSet = `1` << `1`,
10473	AllFieldsSet = (TypeSet \| DataSet)
10474	};
10475
10476	template<int STATE>
10477	class Builder {
10478	private:
10479	RefPtr<JSON::Object> m_result;
10480
10481	template<int STEP> Builder<STATE \| STEP>& castState()
10482	{
10483	return *reinterpret_cast<Builder<STATE \| STEP>>(this*);
10484	}
10485
10486	Builder(Ref</TimelineEvent/JSON::Object>&& object)
10487	: m_result (WTFMove(object))
10488	{
10489	COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
10490	}
10491	friend class TimelineEvent;
10492	public:
10493
10494	Builder<STATE \| TypeSet>& setType(Protocol::Timeline::EventType in_type)
10495	{
10496	COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
10497	m_result ->setString("type"_s, Protocol::Helpers::getEnumConstantValue(in_type));
10498	return castState<TypeSet>();
10499	}
10500
10501	Builder<STATE \| DataSet>& setData(Ref<JSON::Object>&& in_data)
10502	{
10503	COMPILE_ASSERT(!(STATE & DataSet), property_data_already_set);
10504	m_result ->setObject("data"_s, WTFMove(in_data));
10505	return castState<DataSet>();
10506	}
10507
10508	Ref<TimelineEvent> release()
10509	{
10510	COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
10511	COMPILE_ASSERT(sizeof(TimelineEvent) == sizeof(JSON::Object), cannot_cast);
10512
10513	Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
10514	auto result = WTFMove(*reinterpret_cast<Ref<TimelineEvent>*>(&jsonResult));
10515	return result;
10516	}
10517	};
10518
10519	/*
10520	* Synthetic constructor:
10521	* Ref<TimelineEvent> result = TimelineEvent::create()
10522	* .setType(...)
10523	* .setData(...)
10524	* .release();
10525	*/
10526	static Builder<NoFieldsSet> create()
10527	{
10528	return Builder<NoFieldsSet>(JSON::Object::create());
10529	}
10530
10531	void setChildren(Ref<JSON::ArrayOf<Protocol::Timeline::TimelineEvent>>&& in_opt_children)
10532	{
10533	JSON::ObjectBase::setArray("children"_s, WTFMove(in_opt_children));
10534	}
10535
10536	// Property names for type generated as open.
10537	JS_EXPORT_PRIVATE static const ASCIILiteral typeKey;
10538	JS_EXPORT_PRIVATE static const ASCIILiteral dataKey;
10539	JS_EXPORT_PRIVATE static const ASCIILiteral childrenKey;
10540	};
10541
10542	} // Timeline
10543
10544	template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Debugger::Location> {
10545	static void assertValueHasExpectedType(JSON::Value*);
10546	};
10547	template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Debugger::FunctionDetails> {
10548	static Ref<Protocol::Debugger::FunctionDetails> runtimeCast(Ref<JSON::Value>&& value);
10549	static void assertValueHasExpectedType(JSON::Value*);
10550	};
10551	template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Debugger::CallFrame> {
10552	static Ref<Protocol::Debugger::CallFrame> runtimeCast(Ref<JSON::Value>&& value);
10553	static void assertValueHasExpectedType(JSON::Value*);
10554	};
10555	template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Debugger::Scope> {
10556	static void assertValueHasExpectedType(JSON::Value*);
10557	};
10558	template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Debugger::Scope::Type> {
10559	static void assertValueHasExpectedType(JSON::Value*);
10560	};
10561	template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::RemoteObject> {
10562	static Ref<Protocol::Runtime::RemoteObject> runtimeCast(Ref<JSON::Value>&& value);
10563	static void assertValueHasExpectedType(JSON::Value*);
10564	};
10565	template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::RemoteObject::Type> {
10566	static void assertValueHasExpectedType(JSON::Value*);
10567	};
10568	template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::RemoteObject::Subtype> {
10569	static void assertValueHasExpectedType(JSON::Value*);
10570	};
10571	template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::ObjectPreview> {
10572	static Ref<Protocol::Runtime::ObjectPreview> runtimeCast(Ref<JSON::Value>&& value);
10573	static void assertValueHasExpectedType(JSON::Value*);
10574	};
10575	template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::ObjectPreview::Type> {
10576	static void assertValueHasExpectedType(JSON::Value*);
10577	};
10578	template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::ObjectPreview::Subtype> {
10579	static void assertValueHasExpectedType(JSON::Value*);
10580	};
10581	template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::PropertyPreview> {
10582	static void assertValueHasExpectedType(JSON::Value*);
10583	};
10584	template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::PropertyPreview::Type> {
10585	static void assertValueHasExpectedType(JSON::Value*);
10586	};
10587	template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::PropertyPreview::Subtype> {
10588	static void assertValueHasExpectedType(JSON::Value*);
10589	};
10590	template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::EntryPreview> {
10591	static void assertValueHasExpectedType(JSON::Value*);
10592	};
10593	template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::CollectionEntry> {
10594	static Ref<Protocol::Runtime::CollectionEntry> runtimeCast(Ref<JSON::Value>&& value);
10595	static void assertValueHasExpectedType(JSON::Value*);
10596	};
10597	template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::PropertyDescriptor> {
10598	static Ref<Protocol::Runtime::PropertyDescriptor> runtimeCast(Ref<JSON::Value>&& value);
10599	static void assertValueHasExpectedType(JSON::Value*);
10600	};
10601	template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::InternalPropertyDescriptor> {
10602	static Ref<Protocol::Runtime::InternalPropertyDescriptor> runtimeCast(Ref<JSON::Value>&& value);
10603	static void assertValueHasExpectedType(JSON::Value*);
10604	};
10605	template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Timeline::TimelineEvent> {
10606	static Ref<Protocol::Timeline::TimelineEvent> runtimeCast(Ref<JSON::Value>&& value);
10607	static void assertValueHasExpectedType(JSON::Value*);
10608	};
10609	template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Timeline::EventType> {
10610	static void assertValueHasExpectedType(JSON::Value*);
10611	};
10612
10613	namespace Helpers {
10614
10615	template<typename ProtocolEnumType>
10616	std::optional<ProtocolEnumType> parseEnumValueFromString(const String&);
10617
10618	// Enums in the 'Animation' Domain
10619	template<>
10620	JS_EXPORT_PRIVATE std::optional<Protocol::Animation::AnimationState> parseEnumValueFromString<Protocol::Animation::AnimationState>(const String&);
10621	template<>
10622	JS_EXPORT_PRIVATE std::optional<Protocol::Animation::PlaybackDirection> parseEnumValueFromString<Protocol::Animation::PlaybackDirection>(const String&);
10623	template<>
10624	JS_EXPORT_PRIVATE std::optional<Protocol::Animation::FillMode> parseEnumValueFromString<Protocol::Animation::FillMode>(const String&);
10625
10626	#if defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE
10627	// Enums in the 'CPUProfiler' Domain
10628	template<>
10629	JS_EXPORT_PRIVATE std::optional<Protocol::CPUProfiler::ThreadInfo::Type> parseEnumValueFromString<Protocol::CPUProfiler::ThreadInfo::Type>(const String&);
10630	#endif // defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE
10631
10632	// Enums in the 'CSS' Domain
10633	template<>
10634	JS_EXPORT_PRIVATE std::optional<Protocol::CSS::StyleSheetOrigin> parseEnumValueFromString<Protocol::CSS::StyleSheetOrigin>(const String&);
10635	template<>
10636	JS_EXPORT_PRIVATE std::optional<Protocol::CSS::PseudoId> parseEnumValueFromString<Protocol::CSS::PseudoId>(const String&);
10637	template<>
10638	JS_EXPORT_PRIVATE std::optional<Protocol::CSS::CSSPropertyStatus> parseEnumValueFromString<Protocol::CSS::CSSPropertyStatus>(const String&);
10639	template<>
10640	JS_EXPORT_PRIVATE std::optional<Protocol::CSS::LayoutContextType> parseEnumValueFromString<Protocol::CSS::LayoutContextType>(const String&);
10641	template<>
10642	JS_EXPORT_PRIVATE std::optional<Protocol::CSS::LayoutContextTypeChangedMode> parseEnumValueFromString<Protocol::CSS::LayoutContextTypeChangedMode>(const String&);
10643	template<>
10644	JS_EXPORT_PRIVATE std::optional<Protocol::CSS::Grouping::Type> parseEnumValueFromString<Protocol::CSS::Grouping::Type>(const String&);
10645
10646	// Enums in the 'Canvas' Domain
10647	template<>
10648	JS_EXPORT_PRIVATE std::optional<Protocol::Canvas::ContextType> parseEnumValueFromString<Protocol::Canvas::ContextType>(const String&);
10649	#if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) \|\| (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
10650	template<>
10651	JS_EXPORT_PRIVATE std::optional<Protocol::Canvas::ProgramType> parseEnumValueFromString<Protocol::Canvas::ProgramType>(const String&);
10652	#endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) \|\| (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
10653	#if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) \|\| (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
10654	template<>
10655	JS_EXPORT_PRIVATE std::optional<Protocol::Canvas::ShaderType> parseEnumValueFromString<Protocol::Canvas::ShaderType>(const String&);
10656	#endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) \|\| (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
10657
10658	// Enums in the 'Console' Domain
10659	template<>
10660	JS_EXPORT_PRIVATE std::optional<Protocol::Console::ChannelSource> parseEnumValueFromString<Protocol::Console::ChannelSource>(const String&);
10661	template<>
10662	JS_EXPORT_PRIVATE std::optional<Protocol::Console::ChannelLevel> parseEnumValueFromString<Protocol::Console::ChannelLevel>(const String&);
10663	template<>
10664	JS_EXPORT_PRIVATE std::optional<Protocol::Console::ConsoleMessage::Level> parseEnumValueFromString<Protocol::Console::ConsoleMessage::Level>(const String&);
10665	template<>
10666	JS_EXPORT_PRIVATE std::optional<Protocol::Console::ConsoleMessage::Type> parseEnumValueFromString<Protocol::Console::ConsoleMessage::Type>(const String&);
10667
10668	// Enums in the 'DOM' Domain
10669	template<>
10670	JS_EXPORT_PRIVATE std::optional<Protocol::DOM::PseudoType> parseEnumValueFromString<Protocol::DOM::PseudoType>(const String&);
10671	template<>
10672	JS_EXPORT_PRIVATE std::optional<Protocol::DOM::ShadowRootType> parseEnumValueFromString<Protocol::DOM::ShadowRootType>(const String&);
10673	template<>
10674	JS_EXPORT_PRIVATE std::optional<Protocol::DOM::CustomElementState> parseEnumValueFromString<Protocol::DOM::CustomElementState>(const String&);
10675	template<>
10676	JS_EXPORT_PRIVATE std::optional<Protocol::DOM::LiveRegionRelevant> parseEnumValueFromString<Protocol::DOM::LiveRegionRelevant>(const String&);
10677	template<>
10678	JS_EXPORT_PRIVATE std::optional<Protocol::DOM::AccessibilityProperties::Checked> parseEnumValueFromString<Protocol::DOM::AccessibilityProperties::Checked>(const String&);
10679	template<>
10680	JS_EXPORT_PRIVATE std::optional<Protocol::DOM::AccessibilityProperties::Current> parseEnumValueFromString<Protocol::DOM::AccessibilityProperties::Current>(const String&);
10681	template<>
10682	JS_EXPORT_PRIVATE std::optional<Protocol::DOM::AccessibilityProperties::Invalid> parseEnumValueFromString<Protocol::DOM::AccessibilityProperties::Invalid>(const String&);
10683	template<>
10684	JS_EXPORT_PRIVATE std::optional<Protocol::DOM::AccessibilityProperties::LiveRegionStatus> parseEnumValueFromString<Protocol::DOM::AccessibilityProperties::LiveRegionStatus>(const String&);
10685
10686	// Enums in the 'DOMDebugger' Domain
10687	template<>
10688	JS_EXPORT_PRIVATE std::optional<Protocol::DOMDebugger::DOMBreakpointType> parseEnumValueFromString<Protocol::DOMDebugger::DOMBreakpointType>(const String&);
10689	template<>
10690	JS_EXPORT_PRIVATE std::optional<Protocol::DOMDebugger::EventBreakpointType> parseEnumValueFromString<Protocol::DOMDebugger::EventBreakpointType>(const String&);
10691
10692	// Enums in the 'Debugger' Domain
10693	template<>
10694	JS_EXPORT_PRIVATE std::optional<Protocol::Debugger::BreakpointAction::Type> parseEnumValueFromString<Protocol::Debugger::BreakpointAction::Type>(const String&);
10695	template<>
10696	JS_EXPORT_PRIVATE std::optional<Protocol::Debugger::Scope::Type> parseEnumValueFromString<Protocol::Debugger::Scope::Type>(const String&);
10697
10698	// Enums in the 'Heap' Domain
10699	template<>
10700	JS_EXPORT_PRIVATE std::optional<Protocol::Heap::GarbageCollection::Type> parseEnumValueFromString<Protocol::Heap::GarbageCollection::Type>(const String&);
10701
10702	// Enums in the 'IndexedDB' Domain
10703	template<>
10704	JS_EXPORT_PRIVATE std::optional<Protocol::IndexedDB::Key::Type> parseEnumValueFromString<Protocol::IndexedDB::Key::Type>(const String&);
10705	template<>
10706	JS_EXPORT_PRIVATE std::optional<Protocol::IndexedDB::KeyPath::Type> parseEnumValueFromString<Protocol::IndexedDB::KeyPath::Type>(const String&);
10707
10708	#if defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE
10709	// Enums in the 'Memory' Domain
10710	template<>
10711	JS_EXPORT_PRIVATE std::optional<Protocol::Memory::CategoryData::Type> parseEnumValueFromString<Protocol::Memory::CategoryData::Type>(const String&);
10712	#endif // defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE
10713
10714	// Enums in the 'Network' Domain
10715	template<>
10716	JS_EXPORT_PRIVATE std::optional<Protocol::Network::NetworkStage> parseEnumValueFromString<Protocol::Network::NetworkStage>(const String&);
10717	template<>
10718	JS_EXPORT_PRIVATE std::optional<Protocol::Network::ResourceErrorType> parseEnumValueFromString<Protocol::Network::ResourceErrorType>(const String&);
10719	template<>
10720	JS_EXPORT_PRIVATE std::optional<Protocol::Network::Response::Source> parseEnumValueFromString<Protocol::Network::Response::Source>(const String&);
10721	template<>
10722	JS_EXPORT_PRIVATE std::optional<Protocol::Network::Metrics::Priority> parseEnumValueFromString<Protocol::Network::Metrics::Priority>(const String&);
10723	template<>
10724	JS_EXPORT_PRIVATE std::optional<Protocol::Network::Initiator::Type> parseEnumValueFromString<Protocol::Network::Initiator::Type>(const String&);
10725
10726	// Enums in the 'Page' Domain
10727	template<>
10728	JS_EXPORT_PRIVATE std::optional<Protocol::Page::Setting> parseEnumValueFromString<Protocol::Page::Setting>(const String&);
10729	template<>
10730	JS_EXPORT_PRIVATE std::optional<Protocol::Page::ResourceType> parseEnumValueFromString<Protocol::Page::ResourceType>(const String&);
10731	template<>
10732	JS_EXPORT_PRIVATE std::optional<Protocol::Page::CoordinateSystem> parseEnumValueFromString<Protocol::Page::CoordinateSystem>(const String&);
10733	template<>
10734	JS_EXPORT_PRIVATE std::optional<Protocol::Page::CookieSameSitePolicy> parseEnumValueFromString<Protocol::Page::CookieSameSitePolicy>(const String&);
10735	#if (defined(ENABLE_DARK_MODE_CSS) && ENABLE_DARK_MODE_CSS) \|\| (defined(HAVE_OS_DARK_MODE_SUPPORT) && HAVE_OS_DARK_MODE_SUPPORT)
10736	template<>
10737	JS_EXPORT_PRIVATE std::optional<Protocol::Page::Appearance> parseEnumValueFromString<Protocol::Page::Appearance>(const String&);
10738	#endif // (defined(ENABLE_DARK_MODE_CSS) && ENABLE_DARK_MODE_CSS) \|\| (defined(HAVE_OS_DARK_MODE_SUPPORT) && HAVE_OS_DARK_MODE_SUPPORT)
10739
10740	// Enums in the 'Recording' Domain
10741	template<>
10742	JS_EXPORT_PRIVATE std::optional<Protocol::Recording::Type> parseEnumValueFromString<Protocol::Recording::Type>(const String&);
10743	template<>
10744	JS_EXPORT_PRIVATE std::optional<Protocol::Recording::Initiator> parseEnumValueFromString<Protocol::Recording::Initiator>(const String&);
10745
10746	// Enums in the 'Runtime' Domain
10747	template<>
10748	JS_EXPORT_PRIVATE std::optional<Protocol::Runtime::ExecutionContextType> parseEnumValueFromString<Protocol::Runtime::ExecutionContextType>(const String&);
10749	template<>
10750	JS_EXPORT_PRIVATE std::optional<Protocol::Runtime::SyntaxErrorType> parseEnumValueFromString<Protocol::Runtime::SyntaxErrorType>(const String&);
10751	template<>
10752	JS_EXPORT_PRIVATE std::optional<Protocol::Runtime::RemoteObject::Type> parseEnumValueFromString<Protocol::Runtime::RemoteObject::Type>(const String&);
10753	template<>
10754	JS_EXPORT_PRIVATE std::optional<Protocol::Runtime::RemoteObject::Subtype> parseEnumValueFromString<Protocol::Runtime::RemoteObject::Subtype>(const String&);
10755	template<>
10756	JS_EXPORT_PRIVATE std::optional<Protocol::Runtime::ObjectPreview::Type> parseEnumValueFromString<Protocol::Runtime::ObjectPreview::Type>(const String&);
10757	template<>
10758	JS_EXPORT_PRIVATE std::optional<Protocol::Runtime::ObjectPreview::Subtype> parseEnumValueFromString<Protocol::Runtime::ObjectPreview::Subtype>(const String&);
10759	template<>
10760	JS_EXPORT_PRIVATE std::optional<Protocol::Runtime::PropertyPreview::Type> parseEnumValueFromString<Protocol::Runtime::PropertyPreview::Type>(const String&);
10761	template<>
10762	JS_EXPORT_PRIVATE std::optional<Protocol::Runtime::PropertyPreview::Subtype> parseEnumValueFromString<Protocol::Runtime::PropertyPreview::Subtype>(const String&);
10763
10764	// Enums in the 'ScriptProfiler' Domain
10765	template<>
10766	JS_EXPORT_PRIVATE std::optional<Protocol::ScriptProfiler::EventType> parseEnumValueFromString<Protocol::ScriptProfiler::EventType>(const String&);
10767
10768	// Enums in the 'Target' Domain
10769	template<>
10770	JS_EXPORT_PRIVATE std::optional<Protocol::Target::TargetInfo::Type> parseEnumValueFromString<Protocol::Target::TargetInfo::Type>(const String&);
10771
10772	// Enums in the 'Timeline' Domain
10773	template<>
10774	JS_EXPORT_PRIVATE std::optional<Protocol::Timeline::EventType> parseEnumValueFromString<Protocol::Timeline::EventType>(const String&);
10775	template<>
10776	JS_EXPORT_PRIVATE std::optional<Protocol::Timeline::Instrument> parseEnumValueFromString<Protocol::Timeline::Instrument>(const String&);
10777
10778	} // namespace Helpers
10779
10780	} // namespace Protocol
10781
10782	} // namespace Inspector
10783
10784	namespace WTF {
10785
10786	template<typename T> struct DefaultHash;
10787
10788	// Hash declarations in the 'Animation' Domain
10789	template<>
10790	struct DefaultHash<Inspector::Protocol::Animation::AnimationState> : IntHash<Inspector::Protocol::Animation::AnimationState> { };
10791	template<>
10792	struct DefaultHash<Inspector::Protocol::Animation::PlaybackDirection> : IntHash<Inspector::Protocol::Animation::PlaybackDirection> { };
10793	template<>
10794	struct DefaultHash<Inspector::Protocol::Animation::FillMode> : IntHash<Inspector::Protocol::Animation::FillMode> { };
10795
10796	// Hash declarations in the 'CSS' Domain
10797	template<>
10798	struct DefaultHash<Inspector::Protocol::CSS::StyleSheetOrigin> : IntHash<Inspector::Protocol::CSS::StyleSheetOrigin> { };
10799	template<>
10800	struct DefaultHash<Inspector::Protocol::CSS::PseudoId> : IntHash<Inspector::Protocol::CSS::PseudoId> { };
10801	template<>
10802	struct DefaultHash<Inspector::Protocol::CSS::CSSPropertyStatus> : IntHash<Inspector::Protocol::CSS::CSSPropertyStatus> { };
10803	template<>
10804	struct DefaultHash<Inspector::Protocol::CSS::LayoutContextType> : IntHash<Inspector::Protocol::CSS::LayoutContextType> { };
10805	template<>
10806	struct DefaultHash<Inspector::Protocol::CSS::LayoutContextTypeChangedMode> : IntHash<Inspector::Protocol::CSS::LayoutContextTypeChangedMode> { };
10807
10808	// Hash declarations in the 'Canvas' Domain
10809	template<>
10810	struct DefaultHash<Inspector::Protocol::Canvas::ContextType> : IntHash<Inspector::Protocol::Canvas::ContextType> { };
10811	#if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) \|\| (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
10812	template<>
10813	struct DefaultHash<Inspector::Protocol::Canvas::ProgramType> : IntHash<Inspector::Protocol::Canvas::ProgramType> { };
10814	#endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) \|\| (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
10815	#if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) \|\| (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
10816	template<>
10817	struct DefaultHash<Inspector::Protocol::Canvas::ShaderType> : IntHash<Inspector::Protocol::Canvas::ShaderType> { };
10818	#endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) \|\| (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU)
10819
10820	// Hash declarations in the 'Console' Domain
10821	template<>
10822	struct DefaultHash<Inspector::Protocol::Console::ChannelSource> : IntHash<Inspector::Protocol::Console::ChannelSource> { };
10823	template<>
10824	struct DefaultHash<Inspector::Protocol::Console::ChannelLevel> : IntHash<Inspector::Protocol::Console::ChannelLevel> { };
10825
10826	// Hash declarations in the 'DOM' Domain
10827	template<>
10828	struct DefaultHash<Inspector::Protocol::DOM::PseudoType> : IntHash<Inspector::Protocol::DOM::PseudoType> { };
10829	template<>
10830	struct DefaultHash<Inspector::Protocol::DOM::ShadowRootType> : IntHash<Inspector::Protocol::DOM::ShadowRootType> { };
10831	template<>
10832	struct DefaultHash<Inspector::Protocol::DOM::CustomElementState> : IntHash<Inspector::Protocol::DOM::CustomElementState> { };
10833	template<>
10834	struct DefaultHash<Inspector::Protocol::DOM::LiveRegionRelevant> : IntHash<Inspector::Protocol::DOM::LiveRegionRelevant> { };
10835
10836	// Hash declarations in the 'DOMDebugger' Domain
10837	template<>
10838	struct DefaultHash<Inspector::Protocol::DOMDebugger::DOMBreakpointType> : IntHash<Inspector::Protocol::DOMDebugger::DOMBreakpointType> { };
10839	template<>
10840	struct DefaultHash<Inspector::Protocol::DOMDebugger::EventBreakpointType> : IntHash<Inspector::Protocol::DOMDebugger::EventBreakpointType> { };
10841
10842	// Hash declarations in the 'Network' Domain
10843	template<>
10844	struct DefaultHash<Inspector::Protocol::Network::NetworkStage> : IntHash<Inspector::Protocol::Network::NetworkStage> { };
10845	template<>
10846	struct DefaultHash<Inspector::Protocol::Network::ResourceErrorType> : IntHash<Inspector::Protocol::Network::ResourceErrorType> { };
10847
10848	// Hash declarations in the 'Page' Domain
10849	template<>
10850	struct DefaultHash<Inspector::Protocol::Page::Setting> : IntHash<Inspector::Protocol::Page::Setting> { };
10851	template<>
10852	struct DefaultHash<Inspector::Protocol::Page::ResourceType> : IntHash<Inspector::Protocol::Page::ResourceType> { };
10853	template<>
10854	struct DefaultHash<Inspector::Protocol::Page::CoordinateSystem> : IntHash<Inspector::Protocol::Page::CoordinateSystem> { };
10855	template<>
10856	struct DefaultHash<Inspector::Protocol::Page::CookieSameSitePolicy> : IntHash<Inspector::Protocol::Page::CookieSameSitePolicy> { };
10857	#if (defined(ENABLE_DARK_MODE_CSS) && ENABLE_DARK_MODE_CSS) \|\| (defined(HAVE_OS_DARK_MODE_SUPPORT) && HAVE_OS_DARK_MODE_SUPPORT)
10858	template<>
10859	struct DefaultHash<Inspector::Protocol::Page::Appearance> : IntHash<Inspector::Protocol::Page::Appearance> { };
10860	#endif // (defined(ENABLE_DARK_MODE_CSS) && ENABLE_DARK_MODE_CSS) \|\| (defined(HAVE_OS_DARK_MODE_SUPPORT) && HAVE_OS_DARK_MODE_SUPPORT)
10861
10862	// Hash declarations in the 'Recording' Domain
10863	template<>
10864	struct DefaultHash<Inspector::Protocol::Recording::Type> : IntHash<Inspector::Protocol::Recording::Type> { };
10865	template<>
10866	struct DefaultHash<Inspector::Protocol::Recording::Initiator> : IntHash<Inspector::Protocol::Recording::Initiator> { };
10867
10868	// Hash declarations in the 'Runtime' Domain
10869	template<>
10870	struct DefaultHash<Inspector::Protocol::Runtime::ExecutionContextType> : IntHash<Inspector::Protocol::Runtime::ExecutionContextType> { };
10871	template<>
10872	struct DefaultHash<Inspector::Protocol::Runtime::SyntaxErrorType> : IntHash<Inspector::Protocol::Runtime::SyntaxErrorType> { };
10873
10874	// Hash declarations in the 'ScriptProfiler' Domain
10875	template<>
10876	struct DefaultHash<Inspector::Protocol::ScriptProfiler::EventType> : IntHash<Inspector::Protocol::ScriptProfiler::EventType> { };
10877
10878	// Hash declarations in the 'Timeline' Domain
10879	template<>
10880	struct DefaultHash<Inspector::Protocol::Timeline::EventType> : IntHash<Inspector::Protocol::Timeline::EventType> { };
10881	template<>
10882	struct DefaultHash<Inspector::Protocol::Timeline::Instrument> : IntHash<Inspector::Protocol::Timeline::Instrument> { };
10883
10884	} // namespace WTF
10885

Browse the source code of webkit/WebKitBuild/Debug/JavaScriptCore.framework/Versions/A/PrivateHeaders/InspectorProtocolObjects.h